{
  "cells": [
    {
      "cell_type": "markdown",
      "id": "5d037743",
      "metadata": {
        "id": "5d037743"
      },
      "source": [
        "# Beat detection\n",
        "In this tutorial we will learn how to detect beats in PPG and BP signals.\n",
        "\n",
        "Our **objectives** are to:\n",
        "- Call Python functions that are stored in a separate file\n",
        "- Use beat detection algorithms to detect beats in PPG and BP signals\n",
        "- Compare performance of the algorithms"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "da64c16b",
      "metadata": {
        "id": "da64c16b"
      },
      "source": [
        "<div class=\"alert alert-block alert-warning\"><p><b>Context:</b> A key step in analysing PPG and BP signals is the detection of beats in the signals. This allows individual pulse waves to be analysed, and either: (i) features to be extracted from PPG pulse waves; or (ii) reference BP values to be extracted from BP pulse waves.</p></div>"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "1afcdef9",
      "metadata": {
        "id": "1afcdef9"
      },
      "source": [
        "---\n",
        "## Setup"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "edd8e0c5",
      "metadata": {
        "id": "edd8e0c5"
      },
      "source": [
        "_These steps have been covered in previous tutorials, so we'll just re-use the code here._"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "id": "ce3cdfde",
      "metadata": {
        "id": "ce3cdfde",
        "outputId": "693c9521-0083-4ff7-edcc-907e37698176",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting wfdb==4.0.0\n",
            "  Downloading wfdb-4.0.0-py3-none-any.whl (161 kB)\n",
            "\u001b[K     |████████████████████████████████| 161 kB 2.9 MB/s \n",
            "\u001b[?25hRequirement already satisfied: scipy<2.0.0,>=1.0.0 in /usr/local/lib/python3.7/dist-packages (from wfdb==4.0.0) (1.4.1)\n",
            "Requirement already satisfied: requests<3.0.0,>=2.8.1 in /usr/local/lib/python3.7/dist-packages (from wfdb==4.0.0) (2.23.0)\n",
            "Requirement already satisfied: matplotlib<4.0.0,>=3.2.2 in /usr/local/lib/python3.7/dist-packages (from wfdb==4.0.0) (3.2.2)\n",
            "Requirement already satisfied: SoundFile<0.12.0,>=0.10.0 in /usr/local/lib/python3.7/dist-packages (from wfdb==4.0.0) (0.10.3.post1)\n",
            "Requirement already satisfied: numpy<2.0.0,>=1.10.1 in /usr/local/lib/python3.7/dist-packages (from wfdb==4.0.0) (1.21.6)\n",
            "Requirement already satisfied: pandas<2.0.0,>=1.0.0 in /usr/local/lib/python3.7/dist-packages (from wfdb==4.0.0) (1.3.5)\n",
            "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb==4.0.0) (2.8.2)\n",
            "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb==4.0.0) (3.0.9)\n",
            "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb==4.0.0) (1.4.3)\n",
            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.7/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb==4.0.0) (0.11.0)\n",
            "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from kiwisolver>=1.0.1->matplotlib<4.0.0,>=3.2.2->wfdb==4.0.0) (4.1.1)\n",
            "Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.7/dist-packages (from pandas<2.0.0,>=1.0.0->wfdb==4.0.0) (2022.1)\n",
            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/dist-packages (from python-dateutil>=2.1->matplotlib<4.0.0,>=3.2.2->wfdb==4.0.0) (1.15.0)\n",
            "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests<3.0.0,>=2.8.1->wfdb==4.0.0) (3.0.4)\n",
            "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests<3.0.0,>=2.8.1->wfdb==4.0.0) (2.10)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests<3.0.0,>=2.8.1->wfdb==4.0.0) (2022.6.15)\n",
            "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests<3.0.0,>=2.8.1->wfdb==4.0.0) (1.24.3)\n",
            "Requirement already satisfied: cffi>=1.0 in /usr/local/lib/python3.7/dist-packages (from SoundFile<0.12.0,>=0.10.0->wfdb==4.0.0) (1.15.0)\n",
            "Requirement already satisfied: pycparser in /usr/local/lib/python3.7/dist-packages (from cffi>=1.0->SoundFile<0.12.0,>=0.10.0->wfdb==4.0.0) (2.21)\n",
            "Installing collected packages: wfdb\n",
            "Successfully installed wfdb-4.0.0\n"
          ]
        }
      ],
      "source": [
        "# Packages\n",
        "import sys\n",
        "from pathlib import Path\n",
        "!pip install wfdb==4.0.0\n",
        "import wfdb"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "id": "ee8532b2",
      "metadata": {
        "id": "ee8532b2"
      },
      "outputs": [],
      "source": [
        "# The name of the MIMIC IV Waveform Database on PhysioNet\n",
        "database_name = 'mimic4wdb/0.1.0' \n",
        "\n",
        "# Segment for analysis\n",
        "segment_names = ['83404654_0005', '82924339_0007', '84248019_0005', '82439920_0004', '82800131_0002', '84304393_0001', '89464742_0001', '88958796_0004', '88995377_0001', '85230771_0004', '86643930_0004', '81250824_0005', '87706224_0003', '83058614_0005', '82803505_0017', '88574629_0001', '87867111_0012', '84560969_0001', '87562386_0001', '88685937_0001', '86120311_0001', '89866183_0014', '89068160_0002', '86380383_0001', '85078610_0008', '87702634_0007', '84686667_0002', '84802706_0002', '81811182_0004', '84421559_0005', '88221516_0007', '80057524_0005', '84209926_0018', '83959636_0010', '89989722_0016', '89225487_0007', '84391267_0001', '80889556_0002', '85250558_0011', '84567505_0005', '85814172_0007', '88884866_0005', '80497954_0012', '80666640_0014', '84939605_0004', '82141753_0018', '86874920_0014', '84505262_0010', '86288257_0001', '89699401_0001', '88537698_0013', '83958172_0001']\n",
        "segment_dirs = ['mimic4wdb/0.1.0/waves/p100/p10020306/83404654', 'mimic4wdb/0.1.0/waves/p101/p10126957/82924339', 'mimic4wdb/0.1.0/waves/p102/p10209410/84248019', 'mimic4wdb/0.1.0/waves/p109/p10952189/82439920', 'mimic4wdb/0.1.0/waves/p111/p11109975/82800131', 'mimic4wdb/0.1.0/waves/p113/p11392990/84304393', 'mimic4wdb/0.1.0/waves/p121/p12168037/89464742', 'mimic4wdb/0.1.0/waves/p121/p12173569/88958796', 'mimic4wdb/0.1.0/waves/p121/p12188288/88995377', 'mimic4wdb/0.1.0/waves/p128/p12872596/85230771', 'mimic4wdb/0.1.0/waves/p129/p12933208/86643930', 'mimic4wdb/0.1.0/waves/p130/p13016481/81250824', 'mimic4wdb/0.1.0/waves/p132/p13240081/87706224', 'mimic4wdb/0.1.0/waves/p136/p13624686/83058614', 'mimic4wdb/0.1.0/waves/p137/p13791821/82803505', 'mimic4wdb/0.1.0/waves/p141/p14191565/88574629', 'mimic4wdb/0.1.0/waves/p142/p14285792/87867111', 'mimic4wdb/0.1.0/waves/p143/p14356077/84560969', 'mimic4wdb/0.1.0/waves/p143/p14363499/87562386', 'mimic4wdb/0.1.0/waves/p146/p14695840/88685937', 'mimic4wdb/0.1.0/waves/p149/p14931547/86120311', 'mimic4wdb/0.1.0/waves/p151/p15174162/89866183', 'mimic4wdb/0.1.0/waves/p153/p15312343/89068160', 'mimic4wdb/0.1.0/waves/p153/p15342703/86380383', 'mimic4wdb/0.1.0/waves/p155/p15552902/85078610', 'mimic4wdb/0.1.0/waves/p156/p15649186/87702634', 'mimic4wdb/0.1.0/waves/p158/p15857793/84686667', 'mimic4wdb/0.1.0/waves/p158/p15865327/84802706', 'mimic4wdb/0.1.0/waves/p158/p15896656/81811182', 'mimic4wdb/0.1.0/waves/p159/p15920699/84421559', 'mimic4wdb/0.1.0/waves/p160/p16034243/88221516', 'mimic4wdb/0.1.0/waves/p165/p16566444/80057524', 'mimic4wdb/0.1.0/waves/p166/p16644640/84209926', 'mimic4wdb/0.1.0/waves/p167/p16709726/83959636', 'mimic4wdb/0.1.0/waves/p167/p16715341/89989722', 'mimic4wdb/0.1.0/waves/p168/p16818396/89225487', 'mimic4wdb/0.1.0/waves/p170/p17032851/84391267', 'mimic4wdb/0.1.0/waves/p172/p17229504/80889556', 'mimic4wdb/0.1.0/waves/p173/p17301721/85250558', 'mimic4wdb/0.1.0/waves/p173/p17325001/84567505', 'mimic4wdb/0.1.0/waves/p174/p17490822/85814172', 'mimic4wdb/0.1.0/waves/p177/p17738824/88884866', 'mimic4wdb/0.1.0/waves/p177/p17744715/80497954', 'mimic4wdb/0.1.0/waves/p179/p17957832/80666640', 'mimic4wdb/0.1.0/waves/p180/p18080257/84939605', 'mimic4wdb/0.1.0/waves/p181/p18109577/82141753', 'mimic4wdb/0.1.0/waves/p183/p18324626/86874920', 'mimic4wdb/0.1.0/waves/p187/p18742074/84505262', 'mimic4wdb/0.1.0/waves/p188/p18824975/86288257', 'mimic4wdb/0.1.0/waves/p191/p19126489/89699401', 'mimic4wdb/0.1.0/waves/p193/p19313794/88537698', 'mimic4wdb/0.1.0/waves/p196/p19619764/83958172']\n",
        "\n",
        "# 3 and 8 are helpful\n",
        "rel_segment_no = 8 \n",
        "rel_segment_name = segment_names[rel_segment_no]\n",
        "rel_segment_dir = segment_dirs[rel_segment_no]"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "61a9432c",
      "metadata": {
        "id": "61a9432c"
      },
      "source": [
        "---\n",
        "## Extract one minute of PPG and ABP signals from this segment"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "3d1d426b",
      "metadata": {
        "id": "3d1d426b"
      },
      "source": [
        "_These steps have been covered in previous tutorials, so we'll just re-use the code here._"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "id": "60464239",
      "metadata": {
        "id": "60464239",
        "outputId": "c03e45df-1855-4eab-e60d-dd3a18d7b76a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Metadata loaded from segment: 88995377_0001\n",
            "20 seconds of data extracted from: 88995377_0001\n",
            "Extracted the ABP signal from column 3 of the matrix of waveform data at 62.5 Hz.\n",
            "Extracted the PPG signal from column 4 of the matrix of waveform data at 62.5 Hz.\n"
          ]
        }
      ],
      "source": [
        "# time since the start of the segment at which to begin extracting data\n",
        "start_seconds = 100 \n",
        "no_seconds_to_load = 20\n",
        "\n",
        "segment_metadata = wfdb.rdheader(record_name=rel_segment_name, pn_dir=rel_segment_dir) \n",
        "print(f\"Metadata loaded from segment: {rel_segment_name}\")\n",
        "\n",
        "fs = round(segment_metadata.fs)\n",
        "sampfrom = fs*start_seconds\n",
        "sampto = fs*(start_seconds+no_seconds_to_load)\n",
        "\n",
        "segment_data = wfdb.rdrecord(record_name=rel_segment_name,\n",
        "                             sampfrom=sampfrom,\n",
        "                             sampto=sampto,\n",
        "                             pn_dir=rel_segment_dir)\n",
        "\n",
        "print(f\"{no_seconds_to_load} seconds of data extracted from: {rel_segment_name}\")\n",
        "abp_col = []\n",
        "ppg_col = []\n",
        "\n",
        "for sig_no in range(0,len(segment_data.sig_name)):\n",
        "    if \"ABP\" in segment_data.sig_name[sig_no]:\n",
        "        abp_col = sig_no\n",
        "    if \"Pleth\" in segment_data.sig_name[sig_no]:\n",
        "        ppg_col = sig_no\n",
        "\n",
        "abp = segment_data.p_signal[:,abp_col]\n",
        "ppg = segment_data.p_signal[:,ppg_col]\n",
        "fs = segment_data.fs\n",
        "\n",
        "print(f\"Extracted the ABP signal from column {abp_col} of the matrix of waveform data at {fs:.1f} Hz.\")\n",
        "print(f\"Extracted the PPG signal from column {ppg_col} of the matrix of waveform data at {fs:.1f} Hz.\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "1705ff48",
      "metadata": {
        "id": "1705ff48"
      },
      "source": [
        "---\n",
        "## Filter the BP and PPG signals"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "47a63ea6",
      "metadata": {
        "id": "47a63ea6"
      },
      "source": [
        "_These steps have been covered in previous tutorials, so we'll just re-use the code here._"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "id": "75fd6b99",
      "metadata": {
        "id": "75fd6b99"
      },
      "outputs": [],
      "source": [
        "# package\n",
        "import scipy.signal as sp\n",
        "\n",
        "# filter cut-offs\n",
        "lpf_cutoff = 0.7 # Hz\n",
        "hpf_cutoff = 10 # Hz\n",
        "\n",
        "# create filter\n",
        "sos_filter = sp.butter(10, [lpf_cutoff, hpf_cutoff],\n",
        "                       btype = 'bp',\n",
        "                       analog = False,\n",
        "                       output = 'sos',\n",
        "                       fs = fs)\n",
        "\n",
        "# filter PPG\n",
        "ppg_filt = sp.sosfiltfilt(sos_filter, ppg)\n",
        "\n",
        "# Filter ABP\n",
        "abp_filt = sp.sosfiltfilt(sos_filter, abp)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ef73e57b",
      "metadata": {
        "id": "ef73e57b"
      },
      "source": [
        "---\n",
        "## Beat detection"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "43a45001",
      "metadata": {
        "id": "43a45001"
      },
      "source": [
        "### Setup"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "8f124a8f",
      "metadata": {
        "id": "8f124a8f"
      },
      "source": [
        "- Import the functions required to detect beats by running the cell containing the required functions [below](#functions)."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "b031a895",
      "metadata": {
        "id": "b031a895"
      },
      "source": [
        "<div class=\"alert alert-block alert-info\"><p><b>Question:</b> How have these functions been stored?</p></div>"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "5147241a",
      "metadata": {
        "id": "5147241a"
      },
      "source": [
        "### Detect beats in the PPG signal"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "3f1a4cdf",
      "metadata": {
        "id": "3f1a4cdf"
      },
      "source": [
        "- Detect beats in the PPG signal using three beat detector algorithms:"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def pulse_detect(*args, **kwargs):\n",
        "    \"\"\"\n",
        "    Placeholder for a pulse detection function.\n",
        "    \"\"\"\n",
        "    msg = \"\"\"Override the pulse_detect function with the example \n",
        "          provided at the bottom of this notebook.\\n\"\"\"\n",
        "    print(msg)\n",
        "    return None"
      ],
      "metadata": {
        "id": "GUSfOVb0m3hD"
      },
      "id": "GUSfOVb0m3hD",
      "execution_count": 30,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 31,
      "id": "8f245cd9",
      "metadata": {
        "id": "8f245cd9",
        "outputId": "e05d1404-a0b4-4084-97db-4a937ac1664f",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Override the pulse_detect function with the example \n",
            "          provided at the bottom of this notebook.\n",
            "\n",
            "Override the pulse_detect function with the example \n",
            "          provided at the bottom of this notebook.\n",
            "\n",
            "Override the pulse_detect function with the example \n",
            "          provided at the bottom of this notebook.\n",
            "\n"
          ]
        }
      ],
      "source": [
        "temp_fs = 125\n",
        "\n",
        "ppg_ibis_d2max = pulse_detect(ppg_filt, temp_fs, 5, 'd2max')\n",
        "if ppg_ibis_d2max:\n",
        "    print(f\"Detected {len(ppg_ibis_d2max)} beats in the PPG signal using the {'D2max'} algorithm\")\n",
        "\n",
        "ppg_ibis_upslopes = pulse_detect(ppg_filt, temp_fs, 5,'upslopes')\n",
        "if ppg_ibis_upslopes:\n",
        "    print(f\"Detected {len(ppg_ibis_upslopes)} beats in the PPG signal using the {'Upslopes'} algorithm\")\n",
        "\n",
        "ppg_ibis_delineator = pulse_detect(ppg_filt, temp_fs, 5, 'delineator')\n",
        "if ppg_ibis_delineator:\n",
        "    print(f\"Detected {len(ppg_ibis_delineator)} beats in the PPG signal using the {'Delineator'} algorithm\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "0eb51879",
      "metadata": {
        "id": "0eb51879"
      },
      "source": [
        "- Plot the results:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "aa48073c",
      "metadata": {
        "id": "aa48073c",
        "outputId": "618dae0c-f219-45b2-910b-6d37ea8b05ab",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 572
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0.5, 1.0, 'Delineator')"
            ]
          },
          "metadata": {},
          "execution_count": 13
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 576x576 with 3 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfoAAAIZCAYAAABOLf34AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOy9eXSkWXnf/7kqqbSVdqmlltTd6u7pnoUZD8EzGPjZeHyw2WwWJ05CPAYG4rAkJMcOxpkY8C/HZIwhEEJsHxts4gAeYrwQGGyWYTOYH8swDB5mo2fpZXpXS629JJWkur8/qm7prVfv8tyrKkmtvt9z+rRUqqfuW/e9936f7/M8975Ka42Hh4eHh4fH7kTDdl+Ah4eHh4eHR/3gid7Dw8PDw2MXwxO9h4eHh4fHLoYneg8PDw8Pj10MT/QeHh4eHh67GJ7oPTw8PDw8djE80Xt4XOVQSo0ppbRSqnEHXMu8UurQdl+Hh8dugid6D48dBKXUSaXUz5Z/vkMptVYmv3ml1HGl1JsD791ygi5f0zdr9Fl/r5T61eBrWuuc1vp4LT7fw8OjBE/0Hh47G98uk18O+GfAe5VS/2S7L8rDw+PKgSd6D48rBFrrHwCPAddH/V0p9VKl1KNKqTml1Fml1G/EvC+jlHqfUmpCKXUc+PnQ37uUUh9RSp0vf85/LdtcD/wx8NxyhGG6/P7m8uc9rZS6qJT6Y6VUa+DzXqGU+kel1KxS6iml1IuVUncBPwX8Qfmz/qD8Xq2UuiZwHR9TSl1SSp1SSr1DKdVQ/tsdSqlvltudUkqdUEq9ZJNd7OGxK+GJ3sPjCoFS6lbgKHB/zFs+ArxRa90B3Ah8NeZ9/wb4BeCfALcAvxT6+/8GVoFryu95IfCrWuvHgDexHmXoLr//98rX9cyyzQjw2+VrfjbwMeBtQDfwfOCk1vrtwD8Abyl/1lsirvP3gS7gEPDTwGuA1wX+/hPAMaAfeC/wEaWUivnOHh5XLTzRe3jsbDxHKTWtlJoD7gM+DjwR894V4AalVKfWekpr/UDM+/4F8D+01qe11peBd5s/KKUGgZcCv6a1XtBajwMfAF4V9UFlYn0D8Ota68ta6zngdwPv/9fA/9Jaf0lrXdRan9Va/yjtSyulMuXP+M9a6zmt9Ung/cCrA287pbX+E631GvBRYC8wmPbZHh5XGzzRe3jsbHxHa91dVulDwDMoEWkU/hklkj6llPq6Uuq5Me8bBk4Hfj8V+PkA0AScLzsY08CHgD0xnzUAtAHfD7z/C+XXAfYBTyV+w2j0l68jeG2nKEULDC6YH7TW+fKPOYe2PDx2NTzRe3hcIdBaXwT+BnhZzN+/p7V+BSVS/jTwlzEfdZ4SARvsD/x8GlgG+ssORrfWulNr/QzTTOizJoBF4BmB93eViwfN5x2O+0oxr5vPXaHkeASv82yCjYeHRwQ80Xt4XCFQSvUBvwg8EvG3rFLqdqVUl9Z6BZgFijEf9ZfAf1BKjSqleoA7zR+01ueBe4H3K6U6lVINSqnDSqmfLr/lIjCqlMqW318E/gT4gFJqT/laRpRSLyq//yPA65RSLyh/1ohS6rrAZ0XumS+H4/8SuEsp1aGUOgD8R+DPBV3l4eERgCd6D4+dDVPhPk+p4v4S8O9j3vtq4KRSapZS0dztMe/7E+CLwIPAA8CnQn9/DZAFHgWmgL+mlP+GUoHfI8AFpdRE+bX/BDwJfKfc9peBawG01vdRKqD7ADADfJ11lf5B4JfKVfP/M+I6/z2wABwHvgl8AvhfMd/Jw8MjBkrrpOiZh4eHh4eHx5UMr+g9PDw8PDx2MTzRe3h4eHh47GJ4ovfw8PDw8NjF8ETv4eHh4eGxi+GJ3sPDw8PDYxfDE72Hh4eHh8cuhid6Dw8PDw+PXQxP9B4eHh4eHrsYnug9PDw8PDx2MTzRe3h4eHh47GJ4ovfw8PDw8NjF8ETv4eHh4eGxi+GJ3sPDw8PDYxfDE72Hh4eHh8cuhid6Dw8PDw+PXQxP9B4eHh4eHrsYnug9PDw8PDx2MTzRe3h4eHh47GJ4ovfw8PDw8NjF8ETv4eHh4eGxi+GJ3sPDw8PDYxfDE72Hh4eHh8cuhid6Dw8PDw+PXQxP9B4eHh4eHrsYnug9PDw8PDx2MTzRe3h4eHh47GJ4ovfw8PDw8NjF8ETv4eHh4eGxi+GJ3sPDw8PDYxfDE72Hh4eHh8cuhid6Dw8PDw+PXQxP9B4eHh4eHrsYnug9PK5iKKVOKqUWlVJzSqlppdS3lFJvUko1lP/+NqXUw+W/n1BKvS1kr5VS40qpxsBrTeXX9FZ/Hw8Pj43wRO/h4fEyrXUHcAD4PeA/AR8p/00BrwF6gBcDb1FKvSpkPwW8JPD7S8qveXh47AB4ovfw8ABAaz2jtb4H+JfAa5VSN2qt36u1fkBrvaq1PgZ8Bvh/QqYfp+QMGLwG+FjwDUqp1ymlHitHBo4rpd4Y+Nt/Ukp910QFlFJvVko9opRqqcf39PC42uCJ3sPDowpa6/uAM8BPBV9XSqnya4+ETD4NPF8p1a2U6im/5zOh94wDvwB0Aq8DPqCUelb5b/8NWAbeoZQ6Avwu8Cta66XafSsPj6sXjelv8fDwuApxDugNvfZfKImDPwu9vgR8llIkQAH3lF+rQGv9d4Ffv66UupeSQ/CA1rqolHoN8ED5M96rtf5Bjb6Hh8dVD6/oPTw8ojACXDa/KKXeQikk//Na6+WI93+s/PcNYfuy/UuUUt9RSl1WSk0DLwX6zd+11ieBrwFjwB/W7mt4eHh4ovfw8KiCUupWSkT/zfLvrwfuBF6gtT4TY/YPwF5g0NgFPq8Z+BvgfcCg1rob+Bwl9W/e8/PAc4GvUArle3h41Ag+dO/h4QGAUqoTeD7wQeDPtdYPKaVup5Qz/xmt9fE4W621Vkq9LPBz8M9ZoBm4BKwqpV4CvBB4uNxuP/CnwL8Gvgs8pJT6jNb6c7X+jh4eVyOU1n6rq4fH1Qql1ElKKnwVKAKPAn8O/LHWek0pdQIYpVQsZ/DnWus3le01cERr/WToc68BntBaq/Lv/w74bUqE/1mgCXhSa/0OpdSngPHAZ76E0va+m7TWk/X55h4eVw880Xt4eHh4eOxi+By9h4eHh4fHLoYneg8PDw8Pj10MT/QeHh4eHh67GJ7oPTw8PDw8djF23fa6/v5+PTY2tt2X4eHh4eHhsWX4/ve/P6G1Hoj6264j+rGxMe6///7tvgwPDw8PD48tg1LqVNzffOjew8PDw8NjF8MTvYeHh4eHxy6GJ3oPDw8PD49dDE/0Hh4eHh4eligWi/z4j/84d9xxx3ZfSio80Xt4eHh4eFjigQce4IEHHuCjH/0oly5d2u7LSYQneg8PDw8PD0s89thjlZ+/973vbeOVpMMTvYeHh4eHhyVOnVrfzfbII49s45WkY9fto/fw8PDw8Kg3Tp8+TX9/P1prjh8/vt2XkwhP9B4eHh4eHpaYmpqir6+P1tZWTp8+vd2XkwhP9B4eHh4eHpaYmZmhq6uLPXv27Hii9zn6GuKBBx7gtttu2/FhHI8dihN3w6fH4BMNpf9P3L3dV3RloNxvD75bUfzUAVm/lW1+9D7Fyl8LbTZxfZ9/5yCf/o/K39ddBEP0+/bt80R/NeHd7343X//61/mLv/iL7b6U7cOJu1n7mwOsfGyXLGpbRb4n7ob73sB/+KNTvO0TGvKn4L43iNpbXl5mfn6+Pte11ThxN/r/HuDh9wjHT7nffvDoKZ75W/Bb//vp9H4r25w+fYrr3wa/+j8FNgFore2+z3f/DS/9r+P84gdgaVp+X3cVdqETGyT6y5cvk8/nt/uSYuGJvoY4f/48AD/4wQ+2+Uq2CeUF9I4PPM3Qv4OZCfmiViwWKRaLW3CRFih/H/KnADvytcaDb2dhIc/v3wvv+zuYXwLW8vDg21NNb775Zp797GdbNbeyssLs7KyVzXe/+13e9KY3USgUrOzEKPf35771NDfdCX90j6C/H3w7rOX5enmn09/+gPR+K9t8+eHSr3/+TYFNGTMzM+zbt4///t//u+w7Pfh2xqcWK7/+6Jy8ra3Cpz71KV760pcyNTVVnwbK93Vu8hT/51savVDHeVR2KI7/D4X+v/WN1BiiHx0dBdjRqt4TfQ1x8uRJAE6cOFG/Rlw9463wqB98O3o1z5//f3B5Hr7zJOJF7Z3vfCft7e1cuHCh9tcVwOXLl/nkJz8pe3OZECbm4Pm/A3/9XcTf58KFC1x33XW8733vk7WVf5qnxtd/ffLC+utJmJ6e5tixYzz22GOMj48nvjeI173udXR1dbG8vCy2ecMb3sCHPvQh/uqv/kps88ADD/CMZzyDL3zhC+lvLvf31x4t/XrvQ6T3d7l/jpe/+mKh+vUkmxPlM04yDVAsptiUce+993L27Fne+ta3pr7XtHU8eF8vCq5vi/He976Xz3/+8/zd3/1dfRoo39fX/DH88h9Scsrq4eyUHYqHj53i8K/DXZ+wi9TYwhD9yMgIsC70diI80dcQly9fBtYJv+YoD+T81Cn+4tua4rzQMy7b/dnnT3H/cTtl+sgjj8gdl/zTTAYiyA+dXn89De9///tZWlriG9/4hqwt4Dvf+Q6/9Vu/ZRVKfelLX8qrXvUqHnroofQ3l6/7bx+AfzgG/+VT1a8n4Rvf+AbHjh3jXe96l+zC2vZz5vL6rxXSb9ufaBbcy/vkk0/K2gLuvvvuynVKYZwwm8NBPvvZz/Loo4/y8Y9/PP3N5X49WSbgpySkWO6f89OlX09NwFqR5H4r/+30ZOnXlTW4OJNiU0awj0Xjrm0/lwKBk0tz1deQhMXFRb797W+nt7FJXLxY6mjRnHBB+f4dO1f61ThyNXd2yg7FveWv8YlvUbfoycrKCvl8nu7uboaGhgDqLlI2A0/0NcLS0hKLi4s0NzczOTnJysqKyK5YLFYchFSUB/J7Pgv/6g/g/3wb2UB+8O2cOJ/n9R+G5xveEdgtLi5y4403ct1118mur20/F6bXfz0/tf56ErTWlf56+OGHZW0BL3zhC3n3u9/Nt771LbGNWcxEBFe+7kfPln69OFP9uqSd2dlZWUri5rs4M5Wt/HpuCsi0wc13JZo9/fT6YikNHc7MzFR+PnbsmMhmYWGhEjH40Y9+JLKB9X4QtRMi7acnq1+PxM13QaatYrNWhMuLrcn9VrY5F4hUjy+0pPY1UFVoKzr29Oa7uDS/fl8vziC6rwB33HEHz3ve83j88cfT2wHnqN3kZKmjg2OppijfvwvlYffEherXa4ZQpGY6X/16LWHmUFdXF3v37gW8or8qYPJb1157LSBcBIAPfvCD9PX1ydRYecD+sLyef/uJ6teT7O57qvTjYgEqQiTFzpBuoVCoLAaJuPkuzs82V369IFzU5ubmKmR47ty59HYCdgD33Xef6P1ra2usrq4C8NRTT6UblAnBLBwTc7C0lkIiZZw9e7bys2gsHLydia5XrNssdsGzPwwHb080C362lOiDERppFODMmTOVn23ukekHkU2ItGfysJjW3wdvh2d/mImF9Z3C4/v/3+R+K9tM5rN0tJReurT311L7GqhKj4iI8eDtjHe+EoC2ZhjP50T3FeBLX/oSAF/84hfT23GsJ1lZWanMo7op0pvvYmGllamF0q9PXETs7Fih7DicLeum89PlWpdaOxRUE313dzfNzc1e0V8NCBO9NF/6J3/yJwDcc8896W8ODeTHzlW/nmT3RGAMjs+uv56EIBmKFNnB27nY/zoA+jvgwlyLaFELThATRkxDsHBIqjAvXbpUKSQTpVfKhHBpYd15eXr4d0SLdPA7SQl4Sh2gtbWVgYEBxntfJWon2A9BMk5CsI+l/W0cisOHD1sRvfn8ixcvsra2lvxmQ9rzis7W0ksXDtyV3g8Hb2dO7+Hw4cMAjGcFhYkHb+dycYRrb7wFgEuNP5ZuA0xMTNDaWro4qTM/3TBGNptl7PANjLe/SHRfgYrzK1L05WjfF38IQ/8Wnp5AFLWbnl4PwdWNqA7ezsThd1d+PTedETs7Vig7imcDkZqzM7JIjS2CRK+UYmhoyCv6qwEm/G7C3FKiN8QjIqtQyPHkJWSe8c138fTlTOVXqV2QDEUKGJjJ3gjA9c/8KS6sHbIixUwmI+63IKlJCS4YlZDacPB2xouH6OrqAuBi9idEZhcuXGDPnj2AXAFPTU3R09PDwMCAmESmpqbIZDJcd911YofC9EN/f7+4vycmJoBShf/k5CRLS0siu4sXL9Lc3EyxWKx8RhL02C8zvwRHn1Ei4AtNzxG1Mzs7yzXXXAPI597U1BRHjx61spmcnKzMccn3AZifn6ejo4M9e/aI25mdna2QyRNPPJHybirRud/6ZCk98JffrX49Dmbd6u3tlRO9Q4pgovUnAbjxxhu5OANr+18la8sGJlKz0Mje7tJLZwZkkRpbmB0rnZ2dAAwNDXlFfzXAKCsbotdaVwhHRKQHb6d4yx9Xcl3npxX61g+JFM945pmVXy8uDViHhaWD2IQBjxw5IvZwzWJz/fXXixWmWQQbGxvF12YIbu/evVaPlRwfH+cZz3gGIFdxExMTleiOKO2BO9F3d3ezf/9+a6K/7rrrnIgeZPnIxcVF8vk8N910k9hmYWEBrXWFgCU2xWKR+fl5K6JfW1tjenqaw4cPk8lkrO6rmeNSm/n5eXK5nBXRBz9b5CiWo3PLpcwUj52tfj0OZt264YYbmJ6eTnfgyimChcunuO8peYrAjJ+bbrqJtbU1sZNkjYO3M1Xo5KZnvxCAs8Xr69LMwkIpD5HL5QC8or9a4BK6n5ycrGxvkhLcXP/LWSvCyMgIiwXNTO8viOwuLTRXFsJLh98t8nInJibYv38/ra2t8uubmyOTyTA2NsbU1JRo+5Yh7aNHjzI+Pi6qZjY21157rfjaDMFdf/314gVXa12l/KSL+9zcHAcPHqxqNw0uRD89PU13dzeDg4NWqhRKfSe1Mc7YjTeWIjYS8jFOn5kTkoXQ2Jj+ljhx5rCgsbExcVTIKLKenh76+/vF/T07O8u+fftobGy0UvS5XI7BwUHxWDX9PTo6KiOQm+9CN7RWdio8NY4oahd0skGwDpVTBG+9G37it+EHJxGlCEw7xmG2Sf/YoFgsMj09XRmnosidQ4RicbF0NoJJ4+zdu9cr+qsBhujHxkr5OMmENgtFV1eX2Bs0OTUzMaV2Lqp0cnKS/v5+BgcHrRR9R0dHZcuJZNE13+no0aMsLi6KTnkLOgcXL14UVbYHlWw+n6945UlYXFykWCxWSFvSd1pr5ubmGBkZobGxUUz0JsRrQ/TBsLCNc9DZ2cnw8DATExPpufNyO0opjhw5AtgRvQ1pG5tDhw7R0NAgGt+GtLu6uhgYGBDNPXPv29vbSzURgnFaKBRYWVmho6OD/v5+a6Lv6+tjenq6UhCahCAxTkxMpB9SdPB2Zq//IEvlzT6nLzeKonamnRtuuAEQrCflVMBXyk9l/dJD1a/Hwcxpm0gNlOb5nXfeWbVTJAmmsHd4eJi+vr50oncsYgwT/dDQEBMTE+LdVlsNT/Q1gpkw3d3d4oUjGDa7fPmySP2GiV7qGV+6dIkDBw7Q1tZmRfR9fX0MDQ1ZKfqOjg76+voqn5EGM4ltQq9BRb+6uio61cssNocOHQJkpG1s+vr66OjoEC3uS0tLrK2t0dnZSW9vr5joFxYWaGtrY2BggMnJSREhBG2kzkswlCzd3jk/P097ezv9/f2A7L4a0jb31Ybou7q6xGQazJdKbcJELxkLLjZQTfSAaKyGFbBk/l1q/xmgFKW4lG+1KuYUpyPKqYD58lL1iDBFYOaRcRSlRP+hD32I97znPdx1l6ygzqyP3d3djIyMpBN9OULxmfthz5vLB1UJIhTmuNugogd5ZHar4Ym+RjALYSaTYWBgQLTYmElmSNtG/doo+uXlZWZmZhgYGLAOU3Z1dTkpehuin56eJpfLVSaLDdHbqEWzUNuoc0M8Nko7aNPX12dF9IZEABEB5/P5KhspYbW3t1eKBSX9vbCwUEVWNkS/Z88e2traRDaGtG1Us4tNkLT7+/tF1xbMy7oqepAV8QVFAMjmubn3N9xwA3NzcxXVmQQzxippvbTxc/NdFHRr5UwJaWGvIXobpw/Wz2EQFSSyPuY6OzsZHR1NJ/pyJOI9fwuXZuF/f6P69TiYvm1rawPY8YfmeKKvEfL5fOWmSxeBMNFLBokhOBtFb65lYGBA7ITA+gJlU1E6OztrTfSzs7N0dnZWbCQENzs7S2NjI2NjY4A8l9vU1FQ5slJCcGaByuVydSd6Q9pGNUvukxl3LkRvbKT9kMvlyGaz5HI50XcK9p10ToT7zsbGjCEb0m5vb3ey2Yyit3GSbELdpq9sUnQzMzO0t7dXnOzU/j54OxfHfq9yFsf5GVmKYH5+nubmZnK5HF1dXeLaEHPyo3QLrRlz7e3tMqIPHdL0wMnq1+MQlaOHnXtojif6GiFI9LaK3oTNbEKbw8PDtLa2iiazec+ePXucFqjBwUFxKNlF0RuCsw33d3Z2Mjg4CMjD8IawpTZB4pFGQzar6G2IfqvUuek7QJyOCPedLdG7hO5dSNso+rQ6j7CNq6K3uT4TfbIRASY8LnX6crkcbW1ttLS0iGwu534agAMHDnButhk99supNsHxY7P7wBxK9PTTT4uKdINRl5GRkaqzMyJRjlCcKt/KJy4gilDk83mUUjQ3l87Y8Io+AUqpFyuljimlnlRK3Rnx9+crpR5QSq0qpX5pO65RirCit8n/mokpye+Y3JBRcTa1ALYV3UFi1FqLlLYL0Zs8sy3RmzwuyEnR5KbBTdG7kJXk+xSLxcoY2ipFb0v07e3tQKleQToWYOuIPtjfaaQQVvTFYjG14Cscobh8+bK4kNGF6G1TMub6KgcHCca3GT9KKfH4DtYPLCwsVO5Z2rW5EL1ZE/P5vKhIN6joh4eHgRTyPXg74wdLEYruttKxy8Vb/jg1QrG4uEhraytKKYCK4PCKPgSlVAb4Q+AlwA3Av1JK3RB629PAHcAntvbq7BFW9DMzM6kVmAsLCyil2LdvHyBfpGGd6OuVZy4UChQKhcqiBjLiMURvE+I1ir6rq4uGhgYrou/t7RVfmyGr9vZ2sXqJIp40EolS9Gk2Zv+yq6K3JQRbojdOEiBWzeFx50r00v42in51dTX1Ebxhoof0/g4rerP1Mglra2vk83mnCEp7ezvNzc10dXVZjVVTbCqN7gTXLUk75jubFIGE3FyIPp/Ps7S0VGnHpg4nWPOTlt4cbykd5nPL836WwiqMt/9cajuG6A2y2Sx9fX1e0Ufg2cCTWuvjWusC8BfAK4Jv0Fqf1Fr/ENhhDyrfiMXFxSpFD7KFo62tjba2Ntrb28UKDuzyhOHFM5/PVz4n6dqAqlC3DdGDnBCMk9TQ0CAOCxuib2xspKenx0rRK6XEi01YxS0tLaX2XZh4CoVCajW8C/HAet/lcjmam5utFH1LS4u4SG4rQ/dKqQqZSkjbtGNDpuHCOhsbG2fMjJVcLkcul6OpqcnasZJG7kw/mHC/lExNpEYaiXTZEx8mepvtx2ZPvNShgFJ/G0WfZmf6yRzsJOm3MNHDzj40ZzuJfgQIHuV1pvyaNZRSb1BK3a+Uut/mxLNaIp/PV268lBjNgmtsJNeez+dpaGggm806K3pIV37BEJhZ1NJszP5xW6IPqgppWNgU8IG8JiIYfrZdPIN9l9ZWMJRsSzxtbW20traKHL+VlRVWVlZob2+3cl6C4663t1e8vS6o6KWh+5aWFhobG+nv72dmZiZ1P/jc3By5XI6GhgYxAS8tLaGUIpvNWjnZ4KbobaJcQeJRSonnRHis2tSgdHR00NzcLHZ+bWuLXAqCg+NncHBQdH6D6SdD9DaKPlhgmEa+pm/N95E62GGi37t3ryf6ekJr/WGt9S1a61vMYrzVCOfoQbZwmMEv9abNIm1yavUmeptFrVAosLq6ah3iDaoKqU04giIl+qCqsMl72vRDOHQPdmoRZN8pWK8BckJwCcNH5ejTitfMYT6AmLRd5tHS0hItLS0VIpW0E3SspDZRzq8N0YOd82s7Vo2TZLM2uCj68HkUNrs2oPR9tNap/eCyKyl4jwYGBmhoaEh1RIxjbmobJH0QXH8MhoeH63bi32axnUR/FtgX+H20/NoViagFKm3AhBW9TajW2EgOSTHEEyzaslmgbBZcWN9y4qLopWFhs7iDnOhdIihzc3M0NTXR3Nwsvq9RoWQpadsQfdg5kHwnU/Rn61gFiae3t1dUvGaIx3wfkJO2uTaJzfLycqX62YboW1payGQymwrdp/V32Bmz6W+X6FPQsXJR9HNzc6kHd83Pz9PS0kJfXx9NTU2iMHyY6CHdQTDz6MCBAzQ1NYlD99lslqamJjKZjCicbtY6m/M1okL3o6OjnDt3TlSgudXYTqL/HnBEKXVQKZUFXgUIntW6MxEmYKhP6D5oYyaMhHhMONRF0Tc3N9PR0ZFqYxaI4EJdL0XvQvTBxcY2HGragfT7uri4uCkSMW25KPq0xTPsUEj6e3V1laWlpSpVCunnHbj0XZC06+kcBOdRZ2en6Ox6Uzzb2toqbsc4v8GxalsTYURAWlFiOIJiq+ht1i2XWhdXou/s7HSKVkEpnJ6msufm5mhoaGB0dBSQhe6jiH7fvn2sra3tyIK8bSN6rfUq8Bbgi8BjwF9qrR9RSv2OUurlAEqpW5VSZ4B/DnxIKfXIdl1vGoKhHFMJbqPobSZm2KGQEL1ZAFyI3tjZLmrmbO80Dzeco3cleslCGPw+i4uLqdGQYMjahnhsySoYSjZ2topeEuIN20j6O/ykLqlqXlpaqiyGLqTt4hx0d3eLdm4E5540d27GaUNDQ6WIVnJtQFXEwVbR79mzh9XV1apnx0chGEFxiRBKoxTBOSF9UE8U0afZuRRzBtuBUjg9TdGbfmtqaqK3t9d6HTYwjoL4EdhbiG3N0WutP6e1Pqq1Pqy1vqv82m9rre8p//w9rfWo1rpda92ntX7Gdl5vEoLFGU1NTaJK8HDBjbQafjNE39XVRVNTkzXRSyaaIfrgooWeL0AAACAASURBVJa2BckUlAWJ3myrScLy8nIVISwvLyeSttZ6QwQF0lVFkKy6u7vJZDJWZNXT04NSypq0XRV9WioniujT8u1hG+PIphGWizoP3lep0g72t3TnRnAsAKJT+ILzFdznhNQptR2rLoo+ak7Y1BZJFL3WuooYzZ5zqaK32RYcvq+SAjmXlEecogfEj4veSuyKYrztxurqKoVCocrDkyoy20kWFWqzIXqllGgR2AzRh8OoSYtuVCgZksPCWusNRA/JfWcKBW37LthOQ0ODiBCCNtLtf+F+kORLo3L0ad8pSp2n5dvj7mta6N4lpB6MhpixauNQmLYk/W07X4NOn9QmKp21urqaeshMmEzBPnKXdpZHsVhkaWmp7ore9EHQYW5sbBQRfXCrpYui37t3L+Pj44n9EO63zeTowSv6XYvwAw5ANmDCoXuQFfdsRtFLry1YvSq12QzRBxV9mk148ZQQffgeSRfPIPGYtmzISmoT7gdJbj9K0dvaSPo7fF9dFH1TUxNdXV1W6hzk/R22kVxb0EYyvsMOhQ3R2xQLFotFp+iTbfFjlHMJspRjWNEnRSjC48fUCkkiFKYWwKXgFqjspU9yRoLrY29vr+jpglHb63p7e2ltbfWKfrcivHhC/RR90MacQFcPog8To4uil5BVVCg5zSaunaTrC9tIF7UoErG1calvcPlOEtXsos7DZGXSEZIcvS1pu6jzKBvbKIAkBB22kTzV0cX5NXMvmG8HmdIOb2eUEL2Z4z09PTQ0NFilMAYHB1leXk481CjcByDr73DNweXLl1OftxFMbYLsYTPB9bG7u1tE9GFHEUoRqNHRUU/0uxUuij4uZ2yj6M1+WZvcneTaYH1xz2azAKIT9aLClGC32EjUogsphq/NJXRv2qqHKg2TqQvR2/SDjcIMt5PJZOju7rYK3Zvr2wpF7+IcSIgkbGMKvZLUrEt/x0Vq0tYT27Re2MnOZDKiYrSotELSGhSee8ZOUowXdlwkYy6otI2iT6q8D7bT09OTWvQIpVSgWRuD2Ldvnyf63QozMYMDzFRAxy0Cy8vLFItF69B9ODQlqbQOLgAgD8M3NzdXHtogiTjUMnSfNKHDBU4212ZspEfGuoThXZ0DWHesTD8kXd9mnANjI3Gswu0YO1vVXK++i2rHRdGnHeISHgvDw8OsrKxY9Z0kyhU+jyKbzaY+2nV1dZVisWjl9EVFIiXRp7Cih+TQeJSiHxwcFCl6mwiFaSvYjkTRB4VQd3c3MzMzqTuFwuPHYGhoSPzAnq2EJ/oaIPxsYihNmJWVldgip7A3bQpUbIuIpKQdDiWnHUcapazAjkQ6OjpobGyse864q6srtRo+bCM9PSyq79IeaRrnHKQpv6Bj5eLwmK1lNpENl/42di6hexfHStLf4WtLeyZBlKKHdMcq2I5ELdYivWKuL+naXKI7UQJFco9sFf1mQve224LDY2HPnj0opawUPZCYilhbW6NYLEYqeuluh62GJ/oaIErxpE0AM/iDYfi0QaK13hCaslHnQRtID/FGEb3NYiPZnxwmHnPOu207aX0XFT6UpD2iyGptbS21Sj1sUygUEh+zGb5HRmlLcufBkHpvb69V6L67uzs13x41viXn3bsoepf+jsrRQzqZ2szXqHYM0Z89G3+gp0t9Qxwx2hK9UipRaYer4UGWcnRV9OH+XlhYSNwKWgtF39jYyODgoFWOHkjM00fNBwPp6YJbDU/0NcBmiD68ECZNMqPAbTx94xyEbSCdtKNsbJVIGtFH9YOterGxCd8jl0prsOs7ae48aNPc3Ex7e7tVkZxpyybqkslk6Onpsb5HktB91BhaXFy0UtrSUHdUf6c5Ly6KPmgzMlJ6BleSWgzXupj+dlH0NqrZPEjINqSeFrpfWlpCa72hut9F0UNyf9eC6CF5L/3q6irLy8uV72MUfVKe3qzDUYre5kmfWwlP9DXAZoh+s2Q1MDDA/Px8JX0QxsrKClprJ6K3XQhdiD6u72yLe+rhHBg7276LI6s0og8rhLQnyy0tLdHQ0EBjY2NVWzahe5DfIxubtbU1VldXrfuhFk6SdIumraIPz4mhoSEgPXSfzWZpaFhfaqXO2GbHd9phMXFiIylVEt5229TURF9fn7VDITkdz2X7cVQ1fNLDZsKF1LVQ9JLr3Gp4oq8BXIg+jqxsF+m0gRW3aCTZmLaCNiYPbhselyp6m/ydi42Lc2Da2mw0xIXgIF01h/P6pi2XMLytou/r62N2djb2IJKo/k7rh9XVVdbW1iJJ2yYML7EJE31vby9KKas5YR50lKbow4TgOicmJiZiCdgQVtBmaGgocftf3NqwtrYWS3RRO4xc5qvkdLxgmjKbzdLZ2Zl4T6PGDyQ7POH6qlopek/0uxBxIVSwU/Rpofs4RQ+1J/ow8Zjng+8ERb+Z0Ga47xYWFmKjIeb6toLo4wghTdGHbVzUYlo7cQ4cxNcQxI1viO+HpHnkEgWwUfTmAUQ2OXpIfzRplI2rok867z7KJo3oXZyxONJ2VfRJ/R0+fc6l36BE9BcvXozcOhm2MUTvquilKYatRiLRK6V+KPj3la262J2KqBtvHpBgk6NP28vrkuuKmsy9vb00NDRYhe7N9aVNtHAo2RB9XMV5kjq3tZmeno7dSeASDVldXd0QfpacUlYrok8L3UeFKdMq/E0/NDU1VV5zccbSwuMupO3iHBgVF1XIGGeztrYWqfzSIjwuRB8VqXFR9C4OvSF6m3nk0o5rNA3i51GxWKRQKGw6fQGle6S1jmwrrOhN6P5qU/QZ4GUJ/14ODNTzAq8ExHl4SRMgafDHLe5R7bhMTHNmu40qNW3Z2vT19VEoFGKra+O+U9LWxKQFyoZE0vou6h61tLSQy+WsCEG6/c81dB9Ef38/KysrsWeph89HADfiSSP6Win6XC5HNptNtQlXWnd1dVk5ISCLJEU5vy73yFaZpjn0cURfKBRSowA2O3JqpehbW1vp6OhIFUK1UvQQvZc+bJPL5chkMs6K3kQEJE8o3EqkEf0btdanEv6dBP7tFlznjkbUhIHkhSNpIaxlGD5u8EvUS5RadCF6SCeEqPoGW1UBdrscXOoojF1SFCCsFiUPZ0kK3Scpsqh7BMlkGnWP5ufnE6Mh4UhN2kE7Uf2dts8/6r6m9V3coutikzQnzIOUoqIuLkSftM8/Kt+epoDjiB6IDd/Xag3as2cPMzMzsVvK4tagJAch7tpqTfRhRa+USj0GN0nRZzIZurq6RMfobiXSiP65SqnRpDdorb9Zw+u5IuGiEFzy7VHEk/bYWVeir6Wih+QQbyaTqSIRlx0LLikMqZNkQwhx/S1ZpKJIZHV1NXb/fRyJQDLRR7UDyaTtcl+huh/S9vnHOVZJfRfX30nH4CbN1yQHLrx7BUp9l1SUmNR3tYw+xVXdQzzRJ+XobdpJK6yLu0dJx+BGHULmUiMUvL6otqJs0o7BTVL0xv5KI/ph4NtKqX9QSv1bpdRVH6aPwmaI3iX8HGwn7bCYzRB9FMEl1RDEqUWwIxHXrYmuNrXsuzjnQLLtLYpEILngzZboo2wkpB1nY1OMZ67PZnybtmxJOykdkaToL1++HEnacTbmHsURQ5IzZpP2qJeiV0pV1WuYA6vS7lH4uG+I3yqXFPG0jV4mncPgQvRRDsVmFD0kEP2Ju+HTY/CJhtL/J+6ObaPWSCR6rfWvA/uBdwA3AT9USn1BKfVapVRHku3VhPChGAZ79uxhcnIykhhdFGac4kmqOK9l6D7tMaiuyi9qAQC3MHzSwqGUqoocdHZ2JkZDkvrb1kZC9LZKOy69Avah+6R2opyDXC5HU1OTU0jdVp27KnqbtIKxgeiK6zgbF2dMquiDdua8+zRiDBKWhOjD9RpgH7GSKPrGxkYymUzV60lCKE7Rg12/mWvt7OzcXkV/4m647w1MXDzF3KKG/Cm47w1bRvap2+t0CV/XWr8ZGAU+APwakPzooasIy8vLNDU1VR2KAckKPanAaStCyUa9xD28wSX/66oW49pJWjjC/W2eFZCUb29paala1NLOu0/r76jceS1D9xLVbEsiSerc5h6lHW+c1A9pTpKNc1BLm6StVWmKPqmANm58J/VdY2NjlVMK9vO8q6uL5ubm2D3kUXPctGPjWEkUfVQ7RtFHnQ1Qq/oBg7h6gC1T9A++Hb2aZ+BNcMs7y6+t5eHBt8e2U0uI99ErpW4Cfgf4Q2AZ+M/1uqgrDVGLJyRPgCgSaWpqoru72zqHaRsCg9JkTnpaV1zoHpInWlz42aadbDZLd3d3KmkHYVIYSc5B3KLm0neFQiHywRdpRJ+07c2276Js0ir8a+VQGDtb1eyq6OOc0jib3t7e2ALDzRB9XDQkiehdFH0cMdpE7pRSiXvpo8YPJDtjroo+7vsUi8XIvqvVzprgNSYRfd0Vff5pniw3//h5WCqsv74VSNtHf0Qp9U6l1CPA3cAC8EKt9XO01h/ckiu8AhA3YZIGpkvlb60VPSSnCVwUfdimqamJzs5Oq9A9pC9qcf1t41CYdmz7LilNkKQwkx7OEleMB/GHd0T1nXF4ahm6jxvfkjy4jcOTZFMsFiMX36QcPUQTcD0UvU06K22f/2ac0vD1JZ0KVyvnt729nba2tlhFHzd+klJ0mwndx7WVJLiiFH2cUy5V9FX2bfs5EfiapybWX98KpCn6LwDNwL/UWv+Y1vp3tdbHt+C6rijEkVXSwFxa2ngGtrFxyRnPzs5Gbm9xIfq4oyTrQQiu6iWuHRuCg+T6hqT+hui+S1KlYJc7N8Rjq7TTVHPYpq2tjZaWFmsnyVXRr66uJkZDbIrXknL0cTYuRO+ao49aGxobGxMfbONKwE1NTZF58CQbl/ED0QVvLooeool+q0P3YUVfKBQqnxdGmqLv7e1leXm5+sTNm+/i9NS6Y3DiEpBpg5vvivyMWiOtGO+w1vodWuuHt+RqrlC4En0t8mPGBuyIx8XGpYLe2Nkq+rQCw7iQ41aopFoTfdwe7ZaWFtra2qwdqzRFb0vatVb0IK9bSbNxCanXUtF3dXWhlLIiekgfdy45bZfxHWeTz+cjq9uTKuhdcvQgV/Td3d2Jz9tII/qoHRVRij7tGFyJot9gf/B2zra9rPLr+FIfPPvDcPD2yM+oNdJC93+b9gGS9yTYvlgpdUwp9aRS6s6IvzcrpT5Z/vt3lVJjrm25YHFxkd/8zd/k3nvvTXxf3GROCuu5LABJ2/ggOZTsQvRRxNPe3l5ToncNw8cRnItDEff86M04STbb3swTBuMIuJaK3pW0k5wDm6JEl3RWUk47TWnXStHHzaOGhgZ6enoS71EtCXhtbS0yhZHm/MalSpJSjnHjOypysBWKvqGhgb1793L27NnYdsI2weuL+k6Li4sbzvFIOwZXkqOHjePosl4/kmbq0Du3jOQhPXT/k0qpexL+fRa4waVhpVSGUmHfS8qf8a+UUuHP+tfAlNb6GkrV/u9xacsVzc3NfPCDH+QrX0k+zj9uIUwqrkuamGkV3Tbb0dK2Etk4B8auliHepGhI3AKVRvS2igdq5yS5KNmk/k46795F0cfdo6QT3pLu68rKSuSBPi4OTz0UfRLRh22y2SxtbW1Wih7S75FLxCqoMIM2ED3uFhcXY8d3oVCIPBI5yVGE6P6OaydN0cf1W0NDg1jRA4yOjnLmzJnYdiCZ6MPXGNXXdVH05d/37duX+Nn1QmPK318h+IzoczPT8WzgSZPzV0r9Rbm9R0Pt/5fyz38N/IFSSum4Kokao6GhgQMHDnDy5MnE98VNZohfdJOIx5xV3tnZuaGdbDYbue8V4j3wsMcKJSckLk+YNGGS8uCuit5MwiCCxWvGw05rJ1i0ZRRd0CZuwYVS342Ojm6wgY2Le1tbG+3t7TUL3ce1A24kYqrUi8XihhqQJHX+6KOPbnjd2MTdVyiRaUdHxwYbiO+HWjlJaY6sjaKH+MNOXO5RXEoGSsT4rW99a8Prpq00BXzttdeKbIL9HV5PlpaW6Orq2mCTtp7EEalJK4THXJzjkvTEwLh5NDo6ykMPPbTh/Uk25vpgI9FHOS5SRW9L9JcvX6a/v5/Z2dnEh1XVA2k5+q8L/n3bse0R4HTg9zPl1yLfo7VeBWaAPsf2nHDgwAFOnTqV+B5Xok8jnigblxBYlI25NpvwM7iF4fv6+piZmYk9OKhW9Q1pyi+p72xIG+IVWZxNe3s7zc3NVpX6EE8i5ulecX0XV+HvWjAZNxYgvkgufD4+uKU9TLGgjVPa3t5ONptN3LplQ/Rp9yiqD1ZXVykWi4m1OLWKPqXZ1GoepW2VixsLcWtQXNFtmqKPS0VEjTmovaLPZDIb0hdp9pcvX6a3t3dbjsjdFc+jV0q9QSl1v1Lq/lo/HnBsbKwuij4p7ArxiieqHXPevS3Rx+UJXUP3acovrjCqVotNGvHUKnRv7GzIyhzOE3WPXEL3Jnzo0ndJtQA2udw01Rxlk8vlYh2euOhT0oNt4ghYKRVLwC6KPskmaY7H2QwMDCTuIU8aqzbzPG09qZVDkbSXPo3opeeMQInoFxYWIp1Y00444hm8Pomil5xfEbfeQzzRz8zM0NXVddUR/VlgX+D30fJrke9RSjUCXcCG3tdaf1hrfYvW+hYzSGuFsbExLl68WL1VIoRah+7BjuCSTnhzIfq00H3UBIh6fnTQBuIJOEkt1lKJJEVQbOobjJ2tcxC3xUcSFg4TcJKNS2Sjr6+P1dVVq1xu0oKYNFbjVJzrPAK7sboZordx+pLaSYskbZWijxMOcdXtaVHFuPHtouibm5s3pAFMei0qT5/UTi6Xi9zrH6XozVMW44i+UCjEhu2BSjokPI4WFhZob2+nt7f3qiL67wFHlFIHlVJZ4FXAPaH33AO8tvzzLwFf3ar8vMGBAwcAEsP39SD6uEkW107chKkH0U9NTW04pSwtCgB2uw9cyMrFxhydG9cPUWd0g1vfxVUmpyn6QqHAwsKC2CauH5Jyxi7q3MWBg+S+ixurcbUhy8vLG55hELSxJfq4RTjNsVpYWNggBtJSP2CngJPOu6+lc9DQ0GC9biWdqx83fsB+3XIletOWRNFLnrKYpOjjHlVriH7HKXql1CuUUv8u8Pt3lVLHy/9+aTMNl3PubwG+CDwG/KXW+hGl1O8opV5efttHgD6l1JPAfwQ2bMGrN8bGxoDNEX3UE5fSCM4m1AZui6fJE4Z9p6SFsK+vD631hkIVicK0UX61ztEnKcy4WgVJf8cp7SiP30XRx6U9XBR90ja+pHHnouhdFvckmzTiiQrXxm1NTHIOXEL3cQ97kti4zFkbYkyqDXEVAVE2Sc98T1P0s7OzlfEctIkq4NsM0UfNv7h2knaupCl6iB5HQaLfUcV4wG9SrbKbgVuB24A3b7ZxrfXntNZHywfz3FV+7be11veUf17SWv9zrfU1Wutnb8epfIbok/L0aUQPGxfdpImZVHhUK88YSpN5dXU1lrSTyDS8qEls4hRZVN91dHTQ1NRkFXI0i5pNO5Dcd0k2S0tLG5T20lL0iYfBdmwcq7iT19JyxrCxv9PSCrAx9FosFlldXY3dPhp3vLGronepdUk6oSwpihTlHPT09DA/P7/hYBVJf4e/U61D98YuziaKsExazybKBcmFulE2XV1dtLa2cu7cOavvE5fbj9vGZxyKWhF9XDsuh04FESb6YrFIPp/fmYoeyGqtg5Xx39RaT2qtnwba63hdOwZ79+6lqalpy4g+Kd/uSlZJRA8bF5u00D3YEX1cmDLuqF1IPrM9re9s+yFJaaf1XdguafEcHBykUChscKzSQvcQT/RxzmI2m40ccxBNPCb0GvV94tqB+JMcaxmuhdI8ikoZpYX7ow70SZpHcYVULo6VxPmtZbrNhrS11jVNryilGB4ejlX0SesWbOyHpPRFX1+f9XyF6NTZ4uLilih6k9Zpb2+nq6uLQqEQeUhXvZBG9D3BX7TWbwn8Wtuqtx2KTCbDvn37NhW6h2h1VStvGkoTc2FhYUOKwIXoJSHH8IRJIoTW1lY6OjpiScRGxZkFKu47DQ0NWS8CLkQfR4wS9RJlA8mhexvSjnOSJAoznGNNageS+y6JRBYXFyPrDpLGgtY6koDjbPr6+mLrG2yJ3kRqoqIALvPInGMR7ru08e3iyEY5YyaNkzRW49qJIkYoiaKwok9y5iGe6OMI2FybK9FfunSpyllMSgNuVtEHnXMzBtvb2ytnTkQVvtYLaUT/XaXUvwm/qJR6I3BffS5p52FsbIwTJ07E/t1V0dt602mKHqIXm1oq+iSCi7OB+PxYkk3UZEvam2yuL0xWxiau74xzEKX80og+ihiTSBHinaQouzjnIE1pJxF9lE1zc3Mk8aS1Mzg4GFmAlRZ+BrmKA/vIGCRHQ1wUvYszD/FO0t69ezf0XRoB79mzJ3L/vW0UQDJfp6enN6jOpHaiFH1aOy5jYTNEH97rn6boo2q/XRS9OT2yvb29cnBR1IOd6oU0ov914HVKqa8ppd5f/vf3wB3Ar9X74nYKxsbGYhV9UiUzuC1QceFQiTq3mTAuRJ+m/Gwmp0TR26QITDsu17a4uLjBw04i7TiiTwtZgx1p9/X1kclkrKIAEE30EnVuq+jjIiguDmZalAuiyTRJ0UN0kVwtib6np4eGhgZrMo16hGzU09SCiDvv3jZ0L3HgwC5iFaXoJXMP7BR90t77JKUd9Z2SFP3KykokGdvk6I2jEFT0huh3jKLXWo9rrZ8HvAs4Wf73O1rr52qtow823oUYGxvj/PnzGypDYf3gEpdFwDZ076Lo0yIHcTYQPTmbmpro7++P9dxtQrwuij7NZmhoiPHx8SrFI11sbBa1gYEBGhoaIomxlqH7hoYGBgYGIh2KOBtIVvQ2pC0hhMnJycingtVyrCalMJJy9BBdTxJn40L0cduxJIreVgFHOfSScP/s7GxlrQq2k+bI2syJ4eFh5ufnqwgs7fvEPcs+bR7Zpi+MHVR/pziHIun8AamiLxQKFcctKnS/YxS9UqpFKfVrwD+ldKb9H2mtv7olV7aDYCrvn3766Q1/S5vMZk9qcGCura2xurqaODGjnqjmGg6N84xbWlrI5XKx3n7cYI4Kj9dL0V++fHlDTi2pnaGhIdbW1qoWdwnBgV1hnTmnO2qBSiKrhoYG635I6rtahe5NOy45eohOR9Qy+uRS61JLRZ9GIi5OqSH6YHhYGuoOztmkUxIhur/r4fwODw8D1Vvs0sYcRBdnpuXo5+bmIs8tSGsH5Ioe7HYKBWHSRmYc7WhFD3wUuAV4iNJT5t5X9yvagUjaYpe2SMNGpZRmE+dNJg0wl8XT2EUpq7gtYuBO9GHlJyEr85AaaTtRIXXpomaTbzdt2Sj6TCYTWUy1mfqGJCdpamqq6vkCEhVnGzlIUn4u9SQuij5pex3UP0cP0fNIougLhUJVW1JFH2wrLdwfRcBSBy44HtIiB2brWzB8n/Z9TFu2OXqwc0Ki7FZWVlhbW4vN0cPmFD1EE/3w8DB33HFHZe5sBdKI/gat9a9orT9E6WS652/BNe04bJbow0rJZTIbuzibXC5HS0uLlY1py9YmqohIokqh+julLTZRW9jSnIPNEL3LwmGTo4fo/OJmQuo2VeqSdubm5qp2bmzGSUoK17a2tlot7m1tbbS1tdUkdJ9E2nGPqk0j+qQ8eJxdEgHbRO7SbEZGSs8KiyLgJNUM1XMiLXLg8n3AXtHH1bqkzdfu7m6y2WzFzozztra2De/drKJPIvrR0VH+7M/+jGc961mJn1FLpBF9RX6VT7K7KjE8PBy7l14Smgov1HFPZjJIOoAjboDFnSEedyCEQZwSSfs+4ZBj2neKWjhc1KIL8UhIMSrfntYPUUWTEucgirTjnroVtLEJ8UYdbOTi8EgdOJu0B0Qf/JJmE1WcmUbauVzOygaiTzVzUfSS0D3YEWPU2pBmYwjYRmm3tLTQ1dVlNfdcFX3UuiVR9LbRS7NGmu+UtGbVU9FvB9KI/mal1KxSak4pNQf8WOD3rask2GZkMhn279+/aUVvFmqX8LOp7o8jUti4xzZtD6tpyybsamyWl5erniDlQiJpqsJFnbvYmJC6bT9EqThJ5W9cO1F7tI3N8vJyVfGOxHmB6oWqno6Vbd/FpTDS+tvWsYpzZJPaiTpRT9LO5ORkVRGoJHQPdkRvzru3UfQDAwNkMhkrRQ/xAiWuHXM6nk2KANaJPth3aTl6sFf0xlai6JNO5tysot8OpFXdZ7TWnVrrjvK/xsDvnVt1kTsBBw4ciNxLL1X0S0tLleKLNPUbtQBIi1psPH1YH/jhKvW07wPRZGozOetB2lFPqZL0XRwBpy3u4aJJV0Vvuy1IUt8AdkTvEg1pb28nl8tF5nLTFnfblFFcgaFL7lxCPLY24cfO1oPoTVs28zyTyTA0NFRF9GmkDfYpR6XUhp0EEqIfHBxkdXW1QopptQBRofu0AudgW+beGqKPOzo47tCczSj6XC6XaFcviKrulVJ/UH7me3Rs8SrAgQMHOH369IbXpWQK6wtoGtHncjk6Ojo2HQKT2MRVqbsSvU24Lc3G5NSi2klKYYSLyiSLjW1hHUQXTUpC1vl8vuq0NmkRkc13cgnxRil6FyfJHPpiE31KO48Cop9gJ6m0tiXtqOIwiUMB0f0dRwq5XI5cLmdN9GHnRWIzPDzsVCRn45hH2Zi1Lko1B21gfdyZMRc3fsxJm8F7JBmn4etLuzaXbc4G4UfVLiwskMlkUh2EesGm6v6lwPvrfkU7FPv37+fcuXOR+4UhnUxhI9GnFby5LgDSFEHUtRm7NFKEaiVivlOS8mttbY1cOFxIO+072drYPNnKII5Mbffypi0ccQTc2NgYuzMiSvVId3u4OEm2hGBUqRmraSfCwdYpepeoSxzRt7REP1nPIE6d2zhJ7jdSewAAIABJREFUEhsXog/XoGyG6JOuLTwnpDa2Y87YmQdLJYXuIf4xxxJFH35UrXlyXdJYqCdsq+5/aguuaUdi//79aK05e/Zs1es2it4MTJeJKXEOzBPVTIpgM0Sf5oRE2STlmZVSTpPTlbRtws/GJljwtra2xsrKirWil+TowY7obU70Mmhubqa7uzuyH+LszGFINs6BuT6bNA6U+m5paalyNKhEkfX39zM9Pb1hy6BE0QcLGSVh+IWFhQ1RF1uiT4vumLZsnF9jE7W9LskmjujT7lHwHAuXuedC9JtxKNKU9uDgICsrK0xNTaVeW9RjjovFIisrK6ntQPV594botwu+6l6I/fv3AxsPzZEqHpCH7mHjudGSwR/O+dVL0ceF1JO+D2ycnNL6hs0qekl/mzoKU/AmXQhh84o+zSbqoB1J+DBOaduQtou6kjqlsN53kmszERSzeJpi0zQCDh9lKnXGwqFhidNnMxZMW8F2JP1tlLapq5GEx4eHh5mYmKjMOck9Mls0jaqVzr3JycmKM5aUBw/agN366BI5gOpIV5qijyrKNBFdSQg+uHtjpxO9qbqfvZqr7gH27dsHxBN92kIdPK9cGro/d+6cVRg+vI3GleiTKl4hPqRukx+zuT4Xog8ezrOZ8GHaQgjril6yyyEupJ5EPFG7AtLIynynsKJXSsVu4wP7raDG5vLly5V91tLQPayTqcQm3N/SAlXYqLRrHXWJS+Ok3aNwDUEa+cDGuhrpPQI71RyOWEmVtta60g8SJ6Snp4empiarawv3m5Tog/dWoujDjzmWRLgMrhiiD1Tdd17tVfebIfqGhgb27NljregXFxcrW9jqRfSmSt1WnZu99AZp+/UhnujToiGXLl2qKASbCIqkujZ4bWCXXunt7UUpVVnUJItA1IEnaY6Vub5w30nuUdS53kl5wihFn8lkaGpqSrQBO9IOK2BJ38URvSSkbq5tbW0tNQoQ5Yyl3SOz7c1W0ZswfFidS8aquU8S58AlPB6+Ry5pysXFRZRSif1ts7892I6tMx++PkmOfnV1tZJegvVDg3abovcoo62tjf7+/g2V99IikOCiKyERlzC8C9FHqXMJ8bgq+uDzoJeWlmhqaiKTySS2Y6sQwsWCNorHpmDSPMzEZiHMZrMbHgfr0t9S58DWJir/K7mvYOckhclUGhkDO4UZlyKwcfrStnsZRBXJSYh+bW2tko7I5/OpjlVYnbtGrJKOuYaNUQqXHUb5fD61INHY2cy98Emb9VD05ghlm+dmBOGJ/grF/v37nRQ92A9kF9Lu6Oigvb3dyjkAN9KOspFMsuDzoKXtQPXCkc1mE52DqEWtsbExMWTtonigujLZZYuPuT5bRS8h4PCRtlKiDz4wRBo5ALu0R5yitwnd26hSm2hDOOpSKBRStwuatmyL8cLREGnUBTav6CVjGzb2t02KQDLmjJ2No+hSqQ/VaVSJoofqZyW4KHqttSf6KwmbIfrgQJYMShdFr5Sqqq51cULM9UmIZ2Jiokqduyg/W6KXXluwHYlNuOBNsthA9eIu7e9wpbUN0QdrNlwIWFqsFFRK0v4290jSD+G90DY1ETYqLuxQSGzMjgUXp88lRw/r9yifzycSNrjVk7jMvbj+tqlvWFxcTP0+xs5mfYyr8Ugbq+axz0FFH9cPUc9KsFX05lG18/Pz23ZYDniit0IU0UtvfHChXlxcpKGhITE8Fz43WrrYuBJ9OGcsIatgRa5riNdF0deD6DOZTGQdhWQxtFkIzfXZ5ujN1kmz5cuFgG2IPqwwJe3YOknBgiopAXd2dlb6W1J70dLSUuVQuDhjNt/HJUcPdv3d1dVFc3NzlXOQFgVoaWmhs7Oz6jultdPU1FRVd2DuUZIyDZ9MKVX0wRM6XWsBIP0eBdtK67eopx/aKnooHZrjif4Kwv79+5mdnd3w2NSk/eMGQ0NDFAoFpqenRQdpdHR0kMvlNkX0UrLas2dPZUtMsVikUChYE4KLopdsEYsiqzSF0NraSmdnpxXBmbZcFL0JbRriSQvRuYTuwyFoaV4f3BS9TTttbW10dHRYKUzTVrhgMu3eRjkHEhuXXK5NtAHWx0Iw6mIbupcoenMmxWbGt8Qxh+jxbVMbInHMjY05Brdeh+wEbcfHx1P7LUrRG6KXKnooEb0P3V9BOHToEADHjx+vvCaZzLA+MM+fPy+emMHHwUqJPrgtz0bRm4I3G8UD1UTvovzS2mlra6sibZuFw0VVuCh68zATKVkNDg4yPT1dtad5K0Lq9SJ605btWLWttDY2NlEAqC6Ss5kTLk7f6upqRQhIcvS9vb1VKSOXnLbEOYCN30mybgUjVvl8nsbGxsRIZLgdm+8DpbVBWo8UjGq4Kvq0bX8QHbq3UfSTk5Pk8/mrT9ErpXqVUl9SSj1R/r8n5n1fUEpNK6X+dquvMQpHjhwB4PHHH6+8Jp0wwYFcT6IPbsuzWdSAipcLdtWr5vrS2unq6qp6HrRN320251ePgiAoLe5ra2tMT09bqVKgcmKb5Du5KPpw/tclciBx4CC67+qh6IOkbeMc2Cr6qNC9tHgtWLORZmNyxsF+cHFKXSJWEpuwopfMPdf5CrJqeFiPatiOBVi/t2l9nc1m6ejoqArdS8cCrIf+zWmqV6OivxP4itb6CPCV8u9R+G/Aq7fsqlJw+PBhlFKbJnobGxeih1Ju35bog960i/JLaye8X9alH6QLYdDGdiE05At2i7tN6B4219+SvmtqaqKvr8+qH8wzCYLEKI1Y2ZwTAdV7yOtJ2q6KfmpqqlJMJbGJcpIkId5wlMLWkXWNcklD90FFLyV6l7kHpeiTtL9tC/iCdktLS5w+fZru7u7E94bPu7ctxgMqW7KvOkUPvILSA3Mo///KqDdprb8CzG3VRaWhtbWVffv28cQTT1ResyV6M5BtycosUGkhoyDRm8NOkraVQbXyk06ynp6eqtP+bFIYNmQFGxeOei6Ey8vLVdGQNLtgZbJN6B7sIihR1eO2Y0ia/w0Tj2t9g0TRm0e72kRDXJ2DYDpLGrEKprNs0ys2c8J2rJqDpNbW1qzmhDnB0DZ0L408AYyOjjIxMcHi4qLV3AN56B6qD+2SbKENt3Xs2LFUou/t7XVW9J7oYVBrbY5VuwAMbubDyo/QvV8pdX/UYwVriaNHj25Q9BLvLng+vM0iPTMzw+LioqiAD6qJfmFhQTS4gsRjs01l7969lbCUy6JWT0VvFNny8rJ4gQqnV0Cu4iYmJqyJXhqmNJ/Z3t5eFe6vV62CC9EPDQ1V+ntpaQmlVKpTGoxS2JD22tqauGgLqnPnNmoR3MaCLdEHnxVvQ9rFYrEy7mzI1MxzqaIvFArMz8+LFb15Lsjp06fF3yd4DG4+n6e5uTnxMB8oORRnzpwB5BEKWF8jJycn66rozaNqzTXuytC9UurLSqmHI/69Ivg+XSpR1TEfI4LW+sNa61u01reYyVYvHDlyhMcff9yqshaqK2Xn5ubo6OhItQlGAaTtBPffS7d0dHZ2VgpbpIsawMGDBzlx4oQz8UiKlaDa4bElbUl1bfDawC6kHgzXmq1v0hy9DdEbu/HxcVZWVigWi3VLYYS3GbqSiOQ0NGOzuLiYehASVPe3bU2Eizp3GQtGAUvH98GDBzlz5gyFQsFK0Zvrc8mDS6vAw6kpG6J/+umnxeMneEy4dH3ct29fpaJd2g6sF1UDIqJ3VfTmUbU7QdGnxzkcobX+2bi/KaUuKqX2aq3PK6X2AuNx791pOHr0KNPT00xOTtLf3y8mYFhfdGdnZyuTLu39YEf0uVyOzs5Ozp07Jyb6YO7chngOHjzIV7/6VZaXlykWi+LogVGlLvUNLqFAlzyhrSq9cOFCRYGkLYbt7e10d3dXFA/I+tvkS21sTGGUjTM2PDzM/fffD9gTvelvyX0NKnrpfXWJAgSdA5utf8bGVJmn2TQ3N9PR0cGlS5dYWVlBay3qh0OHDlEsFivE6FK8ZnuPpGtDODVVL6I313fx4kV6e3vFRA/rkQNpO/v376exsZHV1dWK6o5D+Al20tMvDXp6eiqK/moM3d8DvLb882uBz2zTdVjDVN6bPL0t0V+8eJHZ2Vk6O9OfCRQkenNmtARmL73NIQ2GgG081oMHD3L27NnKRJASffB50C71DfVaCMMqSaJKm5ub6e3t5fz58+LtR7AeDXFR9FKFCaV+yOfzzM7Ois5HABgZGalEDmyq7sGu2DRM2pL7GlTni4uLqc9KCNu4qPPN3CNJiDe4bdfFKbUpkjM28/PzIjINp6Yk7YyMjKCU4tSpU9Zr0MWLF60UPdgTfWNjYyWaMTIykvjevr4+pqamKg8dsrmvUCJ6kwbblaH7FPwe8HNKqSeAny3/jlLqFqXUn5o3KaX+Afgr4AVKqTNKqRdty9UGcPToUWB9i500Rw/rin5ubs6a6G0mTJDopYPLTDKbRW1sbAytNY8++iggJ3pYVxWS6ws7PC5VvBKb4DnYNg7c3r17K0Qv7e+DBw9y8uRJ8aEvsF49bqvoAU6ePCm2GR4eRmtd2bnhEg2Rbj8ye8hdFb00EhK0gXRHtrOzk2w2a3W2hGnL1sYQ/VNPPeVcTyJ14BoaGjh+/Lh4X3dY0UvayWaz7N27l0cffZRisZiqmg1s10fXyEEQhw8fTvz7wMBA1fM5XBS9wVWn6LXWk1rrF2itj2itf1Zrfbn8+v1a618NvO+ntNYDWutWrfWo1vqL23G9QYyNjZHJZCpEb7O4Dw0NMT4+ztTUlNibVkpx4cIFcWEdrBO9jU04dC9V9AA//OEPAXuil16fWdTOnj0rVqUuit7kCW3qG2D9vAOp4oHSODp58qT4tDFYHz+mFsDmoKYTJ06I2zEqxxwMZdOOTf43k8nQ399vpejNaWU2RB8kK6kiU0ptSJXUi+iHh4fJZrMVh1nynTo6OmhpaamIAEl/Z7NZRkZGeOSRRwDZfHXJ0UOJhB966CEgPQ9uYKKKMzMzovXRRA5sFT3A7//+73PkyBFuvfXW1GuCjWfq2yh6g6uO6K9kNDU1cejQoQrR24amTAhI4rE2NjYyMDBgrejN6Xizs7PWoXvbHD1QmdA2pH3y5EnW1tbEBUFKqQpZSRab1tZWurq6Ku1IF6jR0VFOnz7N7OysaLGBakUvbefgwYMsLi5aKe29e/eyurpayfnVS9EbojfpKYlNa2tr5Sx1aegV5IeXGDQ2NtLX12dF9M3NzXR1dVVsJCkZ2EjaNnUUNkTf0NDAwYMHeeCBBwAZMZrHS589e5Z8Pi8m07GxMR5++GEA0T3K5XKVo7ilzhiUiP7YsWMAYkV/6NAhVldXeeihh0TXls1mGRwc5PTp01ZzD+DVr341jz/+eGV+xCHq2O6mpqbUHQEGnuivYFxzzTU89dRTgB3Rj46OVn5OG2DB99l47VBSCIVCgSeeeKKigNJgzpo2+1IlC9TIyAhNTU1WRG/64Ec/+pHYxjg8RmFKPfeRkZGKSrJZCE+dOmVFVkbRLywsWBE9YKXizI4Km34IK3ppjhXW75HEKTVt2Tqlpm7FhkTMvngbmyABS8ePSZUsLS2JzqMItjM3Vzr+Q9oPhw4d4vvf/z5QTQ5JGBwctCbTsbExnnzySfG1KaUYGRnhzJkz1oreQHptN9xwAwArKyuVFE0a9u3bx+nTp5mZmRG3Y4Pw6ZI2qVpYv5dme+x2wRO9Aw4dOsRTTz2F1tpqUQvmg8xezjQYorcN3RtIid44HmbhkJBcJpNh//79ldC9xKazs5OOjo4KidikPYxzJbUJEr10EThw4ACnTp1iZmZGTHB79+6lUChw5swZq9A9UFFXku/kQvQDAwOVvCzIiL6vr49sNstjjz0G2BG9TUU3rI9vqaKH9YI3m3Bt0DmQ5leDNjbtrKysVPbF29RsmPyvC9FLHVnjYMJ6SiMNZr+6K9FLv8/1119f+dmM9TTUm+hdjvoOwnx36RyqFzzRO+Dw4cPMzs5y9uxZtNZWXruBDdHb5oyDny2dzEbFPfbYYzQ0NFgtUKurq4Dcqdi3b5+VoodSPxjikS4cIyMjTE1NAXaKfnl5maeeespK0UOpmErab4bo//Ef/xGQfSdzX03aSNJ3Jg9uQwhKKYaHhyv9bVNMZYhe2ncmCmCrzm225AVtbBX9pUuXrCI1ZiyYtIfL2iAdq0NDQ5UaDxtFbyBVzaOjo5w4ccIqBRYkelMdnwZzNjzI18f9+/fXleiDB/mA7ImbQZjvYVKi2wVP9A4wk9KmCA1KasoMRrNNLw2jo6OcO3eOqakpcTvBSSYl3yDRd3Z2inKYUL1ASQ8r2rdvX4V4bBT9ysoKICf64GJho+ihtJ3IluinpqbEJNLe3s6ePXuYnp6mqanJKnRvnCQbAjbEI7UZGRnh1KlTgH3ofm5uzsqBW1pa4sKFC9aK3kZhukQOBgYGmJ+fZ3x83KrfYN0Zk47va665pvJzkPCSECRQG0fWQHKWB5TWIEN00u9z0003WbcDcOONNwLwzGc+U/T+ffv2sbCwwPz8fF1Us+vzOQxMOsLGph7wRO8AQ24PPvggYLc/8qGHHuLxxx8XPeYQSop5bW2NlZUVsToPLgBSh8KQ4vz8vJVnHFygpJ5usFbBNrUAdorewEXxSNsJhhmlizSsh1F7enpEjlVLSwvd3d0VErEhegMpIbj0nXn87uTkpBXRQ8mxkl7bnj17uHz5MpcuXbJy+i5dusTk5KSYEIzjahPdcSV6Q3Cw7mymIRiGD86pJJjtwWAf7QP5fD148CBHjx7lRS96kbhwDeBTn/oUH/nIR6yI3qAeih42nuZpo+hvvvlmXv3qV/OlL32pLtcmhSd6B5gJZls8A6WBKSXfYFsgn5hKKZ7znOcA8GM/9mMim5aWlsoktvGMbb6LQXBy1pPog5EN6UIYXGSl4cMg0UvvEaw7FVKCC7dlo7QNbJUp2IWSDaT9ELSROknm+xw/flx8beZe/uhHPxL3gQltP/nkk+K+dkmvQLXTJzlwCapJWxoeHxkZYXBwkOc+97nidlwcc6UUjz76KF/4whdE7zc4cuQIr3/968XvD35vm8iBDVyez2GQzWb52Mc+VhXh2A7U7Qjc3YxcLsfg4CD33XcfYLe428KF6AG+/vWvc/bsWau9pSMjI0xOTlp5xj/5kz8JwLXXXiu2CS4c0u8UTBFIbUzYDOTOQVC5SQuCcrkc2WyWQqEgXghh/d7aRAFM7ry1tVW8UAfJ1JawQJ6ScSF6l2hIcE7YpnEuXrwoHt/me+fzeXG/tba20tPTY/0M8oaGBs6fP1/ZlifBzTffXPlZGiGEkoOUdppgEC5ED1i14YqgMx/8uZYYHBys7CyyVfQ7BV7RO+Kaa66pPKygng/SCXqsNu1ks9mqBVECM1Gk6hdKC/rnPvc5vvzlL4ttXMJtQfUidV7GxsY4cOAAL3rRi8Q1B8HPD4bx02BI18YZM/fH5toMMdpEAYILoGSLGFSnZKSh12A0RDpWg9cmJfrg7hVbRQ/yMRe0sYlymWhIc3Oz1d7uoaEhqzGXzWb56le/WtlRIUVbW5sVWbk45luFoKMoTXnYwuX5HDsNnugd8axnPavycz0Hf1C1SfNWrrjuuuuA9POfw3jJS15i5RwElbaURI4ePcrY2BivetWrxO2YbWWf//znxTYAn/jEJ3jd617H8573PLGNqX4OOiRpeNnLXgbAG9/4RrGNIQKbMKXpbxuyuuWWW6rakyAYdZFWdAcjKNLvFFzQXfLMNlEN44TZRF1MW/39/VZOnAt+5md+xtqht0Wwj23Gw1ZAKcW73vUu3vKWt9RV0RcKBaanp69YRe9D94748R//8crPNurKBV/72td46KGH6n7gwgte8AI+8IEPWBGcC0ZHR/nlX/7l1OMng8hkMjzxxBNWhT0gdySCeOUrX8krX/lKK5s//dM/5Td+4zcqtRESmJPubEKcxhmzScnceuut3HbbbfziL/6i2GZ0dJTPfOYzPPe5zxXbBPPRLjnJoPOchKDzK3WsgiFnqROSzWZpbW0ln8+Lc+CwHgmwCXPvZCil+PjHP878/LzTfKo33vGOd9T188OPLL4SFb0nekeYBf2aa66p++C/7bbbuO222+raBsCLX/xiCoXClkzmu+++29pGGnbeDrz+9a+3KiIysM1jvuhFL+InfuInePOb3yy26ejo4Gtf+5rtpfHyl7/c2uaee+7h2LFjVo7Ifffdx5e//GWr1NTzn/98vvGNb1RFh5IQHNM2Cri9vZ18Pm8V5TLvrbcA2Er8yq/8ynZfwrYheGiOV/RXGa699lo+/elPW3n6VwJ2osfusY7+/n6+853vbPdlxOJlL3tZJSUhxa233moV3QG49957OX/+vJVq/rmf+zm+9KUvWRWOvvWtb+XOO++0inKZKIM5SMrjyoYpMjXFkleiover+ibwile8Qhxu9PDwqB2am5ut88V/8zd/w9e+9jWrtMLb3vY2CoWCVaHXy1/+cp7znOfw/ve/3+r6PHYmgo/DtTkMaifBK3oPD4+rAh0dHdYpsIaGBusoV1dXF9/+9retbDx2Ljo7O+np6eHkyZNWD7vaSfCK3sPDw8PDIwEHDhzg8ccfZ3V11RO9h4eHh4fHbsPY2FjlSZOe6D08PDw8PHYZDhw4UDkGd7sfOesCT/QeHh4eHh4JCBZjekXv4eHh4eGxyxDc4bHTjgGWwBO9h4eHh4dHAoKHLF2JZ6d4ovfw8PDw8EhA8ARG22eB7AT4ffQeHh4eHh4JyGazvOtd76KlpcXqkcA7BdtC9EqpXuCTwBhwEvgXWuup0HueCfwR0AmsAXdprT+5tVfq4eHh4eFR/4fn1BPbFbq/E/iK1voI8JXy72HkgddorZ8BvBj4H0qp3fOUCA8PDw8Pjy3AdhH9K4CPln/+KLDhmaBa68e11k+Ufz4HjAPyx1t5eHh4eHh4bBvRD2qtz5d/vgAMJr1ZKfVsIAs8FfP3Nyil7ldK3X/p0qXaXqmHh4eHh8cVjLrl6JVSXwaGIv709uAvWmutlNIJn7MX+DjwWq11Meo9WusPAx8GuOWWW2I/y8PDw8PD42qD0nrreVEpdQy4TWt9vkzkf6+13vCQaKVUJ/D3wO9qrf9a+NmXgFO1vF6gH5io8WduF/x32Znw32XnYjd9H/9ddiZq8V0OaK0j09vbtb3uHuC1wO+V//9M+A1KqSzwf/n/2XvzOMuust77u86peZ7n7q5K0h0yQEOMQTR4eSWMn0vQ+1HBt0FEvAzC+17hdUBRrq/XqFwvKl4QRQWVBIPIi8QJjDEoeCEhcElIyNTpudNd1dU1z3XOWe8fe69Tu3bt4Vmrzqmq7t6/z6c/faan1tprr7V+z+9Zz1ob/kJK8gBxF7odKKUe0lrfXOm/uxvIrmVvIruWvYvL6Xqya9mbqPa17NYa/W8BL1NKPQ3c5r9HKXWzUupP/N/8KPD9wE8opb7l/3v+7lQ3Q4YMGTJkuDSxK4pea30ReGnE5w8BP+W/vhO4c4erliFDhgwZMlxWyI7AleFju12BCiK7lr2J7Fr2Li6n68muZW+iqteyK8l4GTJkyJAhQ4adQaboM2TIkCFDhssYGdFnyJAhQ4YMlzEyovehlHqlUupJpdRRpdSWs/eVUvVKqU/73z+glBrd+VrKoJTap5S6Xyn1HaXUY0qp/xLxm5copWYDOxrevxt1lUApdUIp9W2/ng9FfK+UUr/v35tHlFI37UY906CUujbQ3t9SSs0ppX4m9Js9e1+UUh9XSk0opR4NfNallLpXKfW0/39njO2b/N88rZR6087VOhox1/LbSqkn/D70ubhna6T1x91AzPX8qlLqbKAvvTrGNnHu22nEXMunA9dxQin1rRjbPXVv4ubiHR83Wusr/h+Qxzte9yq8o3YfBq4P/eangT/0X78e+PRu1zvhegaBm/zXrcBTEdfzEuDvdruuwus5AfQkfP9q4B8BBXwP8MBu11lwTXm8458PXCr3BW+7603Ao4HP/jvwXv/1e4EPRNh1Acf8/zv915178FpeDtT4rz8QdS3+d4n9cQ9dz68CP5tilzr37YVrCX3/QeD9l8K9iZuLd3rcZIrewy3AUa31Ma31GnA33oN3ggg+iOevgZcqpdQO1lEMrfU5rfU3/dfzwOPA8O7Wqqp4Ld7BSlpr/TWgwz9xcS/jpcAzWutKn+JYNWit/w2YMu+VUi8B3k3KA6qAVwD3aq2ntPc46nvxnki5awhfi//ZP2mtC/7brwEjO14xR0RdjxCSuW9HkXQt/pz7o8Bf7milHJEwF6c+2I0KjpuM6D0MA6cD78+wlRjLv/Eng1mge0dqtw34SwwvAB6I+PpFSqmHlVL/qJS6YUcrZgcN/JNS6htKqbdGfC+5f3sNryd+sqrofVFKaaXUNaHPflUpVYlzKvI6/QFVl+L9+Um8KFEU0vrjXsK7/KWIj8eEhy+1e/NiYFz7TzaNwJ69N6G5WPJgt4rdm4zoL2MopVqAzwI/o7WeC339Tbyw8WHgfwJ/s9P1s8CtWuubgFcB71RKff9uV2g7UN7xzrcDn4n4+lK6L5ugvXjjJb9fVyn1PqAA3BXzk0ulP34UuBp4PnAOL+R9qePHSFbze/LeJM3FOzFuMqL3cBbYF3g/4n8W+RulVA3QDlzckdo5QClVi9ex7tJa/3/h77XWc1rrBf/1PwC1SqmeHa6mCFrrs/7/E3jPP7gl9BPJ/dtLeBXwTa31ePiL3bgvfgLgGaXULymlJv2EpiOB71/tJxPN44W0g5GsolkmUUq9GKhXSs34iUe3+785C7xRKfWHSql7gV8BflIpdSBQxnP8pKQpPzHsR6PK95PLfraKbfETwH8EjvgT8BYI+uOegNZ6XGtd1N5TP/+Y6HpeMmPHn3f/E/DpuN/sxXsTMxePB8bNIDARYVqxe5M8r4A7AAAgAElEQVQRvYevAweVUmO+2no93oN3gjAP4gH4YeBf4iaC3Ya/jvWnwONa69+J+c2AyTFQSt2C1xf2nOOilGpWSrWa13gJU4+GfnYP8OPKw/cAs4Gw2F5ErCrZxfsygPcErWG8fv4xpZR5ouSfAm/TWrfitf9iwG4FeJM/mX0OeAjoA/4v4C7/b3wRGAKOAL+LN1n9G75i9u/rvcCnfNvXA3+glLo+ovwbgX+p+NV79Xgl8PPA7VrrpZjfSPrjnkAoT+WHiK6nZO7bK7gNeEJrfSbqy714bxLm4iCfRD7YDW/cvFwp1ekvu7zc/8weu52VuFf+4WVuP4WXgfo+/7Nfwxv0AA14odajwIPAVbtd54RruRUvFPQI8C3/36uBtwNv93/zLuAxvCzbrwHfu9v1jrmWq/w6PuzX19yb4LUo4CP+vfs2cPNu1zvheprxiLs98FlV74vfF64JffarwJ3+65fghaqbA9//FfAr/utTwNv8/n8OWMdbL/zvwLPAfXhriatAt29zs38/ftV//xVg3h8/bwZagCKeYnkd8OVQ/f4I+K+h8tsqeB/+MnQtb/HrdjowZswumyHgH5L6427/i7meT/rj4RE8YhkMX4//fsvct9euxf/8z8w4Cfx2T98b4ufibn/cPA38M9Dl//5m4E8C9j/p98ujwJtd65EdgZshw2UOpVQBeK7W+vHAZ3cAQ1rrN/vZ85/RgUc8K6V+G2jRWr9DKfXdwC/jbXt6BG9b0Fd9uzu11iNKqdfhbeX67sDf+C084v/PSqk/Ay5orX8u8P0FvDD5fwB+HQiq6Brgk0nlV6yBMmS4zJGF7jNkuPxxChgNfTYGBLf2dfrhToP9eGodrfXXtdavxQur/w2e2g/jWWCfUio4p+xn85pieb3RT07q8u1OA/+qte4I/GvRWr/DovwMGTLEICP6DBkuf3wa+GWl1IhSKqeUug14Dd55EEH8v0qpOj+p7j8Cn/HfH1FKtWut14E5oBRRxgN4ivznlVK1vtp/Dd6+bINXK6Vu9deC/xvwNa31aeDvgENKqTf6trVKqe9WSl1nUX6GDBlikBF9hgyXP34N+F946+TTeGvrR7TWwUSl8/53z+Ilyb1da/2E/90bgRNKqTm8fIIjhKC9w1Zeg7ejYBL4A+DHA38DvGS7/4p3GMp3AW/wbefxEo1e75d/Hu9kunpp+RkyZIhHtkafIcMVjuBaexXL+DPgjNb6l6tVRoYMGaKRKfoMGTJkyJDhMkZG9BkyZMiQIcNljCx0nyFDhgwZMlzGyBR9hgwZMmTIcBmjZrcrUGn09PTo0dHR3a5GhgwZMmTIsGP4xje+MRk89CqIy47oR0dHeeihh3a7GhkyZMiQIcOOQSl1Mu67LHSfIUOGDBkyXMbIiD5DhgwZMmSwxfG74G9G4VM57//jd+12jWJx2YXuM2TIkCFDhqri+F3w4Fuh6D+Haemk9x5gbO8d3Jgp+gwZMmTIkMEGD78Pikt89kF48Bn/s+KS9/keRKboM2TIkCFDBhssnWJyHn74Q97bwichn/M+34vIFH2GDBkyZMhgg6b9fPXpjbffOrnx+V5ERvQZMmTIkCGDDQ7fwYmLteW3j54G8k1w+I7dq1MCMqLPkCFDhgwZbDB2hFO1L6MmD7V5eHyiDW752J5MxINsjT5DhgwZMmSwxvhKN8MjB8jn85xqeOGeJXnIFH2GDHsHl9C+3D0Hl7bbqfbO7utliZmZGTo6OhgZGeHMmTO7XZ1EZERfQRQKBe677z5KpdJuV2X3kE1qbjD7cpdOAnpjX25a+11u7e1K2LZtt1Pt7ZejF0+itUU5O4XLrf/sIGZnZ2lvb2ffvn2cPn16t6uTiIzoK4j3v//93HbbbXzmM5/Z7arsDi5XstoJtejvy/3WCT+xB9L35e5ke7veIxs71+t5+H3Mzi9x+wfhMSOs0tru4fexvrrEj32YjezparS3f19f9pvw/F8CrQXl7BRc29u1rJ0a4ztUVpDoz549u6cFXkb0FcS3v/1tAO6///5drskuwZ/UvvgIfOSfhJPaXp9sdkotLp1Ca3jB++C574XynJG0LzdwaMfH/sX/rBrt7duszZ3k+ISlQ2FTln89z07DD/0unL4ouB6ApVN88RH422/CG/5g8+dJNv/6BNz9VXjFbwlt/Pp9/Evw+Fn/s7T6LZ1idR3uewweOQXnZgTl7BT867k4b+HsuGCnx/gOlWWIfmRkhPX1dSYmJipeRqWQEX0FcfTo0U3/VwU7oaxcbfzJ63X/E9715wFlKpg8H3wGPvQFC8XjGEJ1UYsUl7j323Bx3v9MoBZL60vc9e/w1DmhTdN+Tk1uvD0ztfF5LJZOUSh6h3a87U+hUNz4PO16/vVx+MDfyq+H4hK/9Gm46t3+fZXco4ffx/LyEnd/FaYXBWX59b77q/A3D8EvflpwPQBN+3nY/0mxtPnzJBuz97kgtVk6xYPPwFv+GI5IHYqm/Rwd33hbjjik7bfeCVXq1/sXPw3f+6vwv57a/HnF4Pefv//fcM17YHyW6kU1Hn4fi4tLvPEPLMaeI4JED+zpdfqM6CuI8XFvRB8/frw6BWwnVOsrslKpiqq0aT+r6zDrH//80PGNz2PhTypv/zj8zCfhy09s/jypbutzJxmftQuh3v1VOPT/+HUUqsUvfQde/lvwf//F1nrH2fz7U566fMsfC20O38Hpmfry26PjpO/Lbdq/4RAATzy78XlS3QBe8uvw3rvh6fOCuvnf/cVXvLd//y2Bjf/9nV+BH/twwKlIsvPr/W3fQTw/s/nzWBy+g2dn8gCcuuh/ltZ2h+/g9JS36Wh5DRZXBDZN+/mm36f/94mt9Y4r59zcxn09NyMoZ6dUqV/v+x7z3pZVfaUPffHv97v+HJ4Zh89/Y/PnlS7r778Fd/47/PhHt9ahUtBaMzc3R3t7O4ODgwCcP38+xWr3kBF9hVAqlZiZ8WamM2fOeIk3aXBcx/3q03DwPXDyAmJltba6RPfb4N13+p8JVdzb/hR+/XNCm8N3cG6uofz2xAVEkydsnCxllFniZOPX7ac/AQM/DZPzgrr5A/3HPuyR2788tvnzpPqZs6zv/87WesfZfPOE9/IrTwptxo5wpvOnym9PzHan78s9fAcnpzZI5PRFRO0dVL1ff2bj8ySbUgnml723ZZJLI4RAO4iI8fAdkG/i2Wnv7RPPIjuEZOwI5/T1gOfALeb2pbfd2BHO6BeU355bHRK199GJjR3JK2uC+o0d4ULvW8pvx5c60svx+/d9j8LLftNzRKoS5fLbe2HFeytub1v49zunvLePSMb4Nsoyc8nc8tY6VAqLi4sUi8VNRH/u3LkUq91DRvQVwtzcHFprhoaGWFtbY25uLtnA99ofe+okP/cpTWFeto4LXoj76Dh87P7NnyfZffkJWFiB3//i1r8XZ3Pigrf2+yt/DesFgc3YEc4N/UL57fnFFtHkua4bMX7R0+dJn2z8OvzJl7y3/yhRmP5Ab2v03hrVKFGLT5731OL0or+0IFCLQUJYWhXYAOeKV5dfT4z8bPq+3LEjnO3cIJHTC12i9j4zs+GMiSIHh+/g3HwDK+t+ORKHwrc7OuFNMccv+J8l2Y0dgVs+xrk578Sx87NQuvkPRfuTz89uTGUXvuffRDYTixtO0oXn/7Wovc+om8tvTy4KnAPggrp2o8y+n0ovx+/HP/L78M+Pwhce3vx5JFyiAGNH0N/9R0z5yyrnFxqrc+jL4TsoqkZO+ktTT52jeqfIHb6Ds35055kJfymnCmXNzs4C0N7eTn9/P5Ap+isCU1NeDPU5z3kOQHpihu+1v+dO+B9/D597CNE6LsAFf6346PnNnyfZPRlwNpfXBHYhm2MTG58n4Zx6Xvn1+YYfEE2eE1d9oPx2YqkpfbJp2r/heABPnNv4PBaH72BhvbHs5R+XRBv8+p3TNwKwsg4T6yMitXg+d1P57ZklGSFMTU2Ry+VoamriwoULib81mK69vvz6dPdPi9r7VO/Plt+emG4WXc/4iNcvWxvg2dm8jBDGjnB+dQjwQ9ZNB2RlLXcC3iR9se2VyWX4mJ2dpbu7GxCMPR9TU1OMjY1Z2VxcaSm/Pn/jp0SkODk5iVKKkZERWTl+P673T1gVnaPuzyczi14ibLGEKAqw0Pvacm7HeW6ozqEvY0eYOvjBciTp5FRN9U6RGzvC2YI3B68VYGJtuCplBYm+rq6O7u7uTNFfCZie9uKNYqL3vXMTpiyHNlPWcYOhzack6te3e+bChsI8NSmwO3wHz1yoLb99UuiFX7zoLZJef/314o4/Xv995dcTtYITpg7fwZnZDVUqigKMHWFidOP7k1P14glgYmGj7c48929ENuMLG2rxzHWfFNlMT0/T0dFBX1+fmHhMv+vt7RUnA03WbTghF5r+DxlZ1d8CwOGbb+XZmTx69P8UlTU+vQp40aSF2x4VlTU7O8tVV10FyFXS/Pw8V1/tRURsiP7aaz21LXWsJicn2b9/f/m1BHNzc7S0tDA4OCir2+E7KNDIBT8oKBp7/rzxzj/z1sL/9pubP4+D6T9goUgdEgUnm18CQF9fH+fmG6t6itz5WcjlPGo789zPVaUss0zb0dEBwMDAQKborwSYAWMmDpOYFwvfOx/3B7MokcoPbZ6d9ha7zk7n5Moqf0v57enFPpGyOtf06vLbs4uCsDDehAtw8OBBccc3k9/AwEB6u/l1m9z3i+W34/My0r7YdCsAtbW1jJeuFk8AExMTHDp0CJATwvj4ODfeeKOVzfT0NJ2dnfT29lrZNDU1cfXVV4sP7TDO2HXXXScmRUNqz3ve81hbWyv/jSQUi0UmJyc5cOAAICOStbU1VldXOXjwICBb9zSJUddccw0gGHu+zfT0tPV9vXjxYtmZl9osLCzQ0tIid+DGjjA+9oGyAj41Lejf/rxhIm/l3JCUCJyJRF577bWMj4+n7wV3TBQ0/ee5z30u8/PzLC4uJv5+O5ienuZ5z/Mii9XKhF9YWACgtbUV8OauTNFfAbAO3R++g5Xihtd+dhqRYl4d+mHmlzV1dXVcmCuxPvKjovpNLDWVvc8Lh35PpuIKg3R2dqKU4nz/u0Q2huivueYazp8/L0pKNN7xtddeKyae2ZbvBXxPunBAVLcgwUknafAmKdvJfXZ2tqwwJaQI7kTf2dnJ8PAwzz77bLoBG33VlegBUVnz8/Norbn+em95QTIRmv5jCFjiHKyurrK+vm6l6JeXl1ldXWVwcJDW1larKIBxQqSKfnFxkZaWFvr7+2WOLDDV8hIAGhoaOLc6KIpykW/ihF+lZyYQzSemL1x//fWsr69vUviRCCQKvvIDfv6JYIkgSPQgTFxz3GI4PT1dLkdE9A7lLC15W4saG72kn8HBwUzRXwkwA8RMUKkTx9gRxsd+s/z2/Jxs3dOQopk8pZ3rwoULZRubMGV/fz89PT3iCWp+fp7GxsbyIRJmIkmCWe86dOgQFy9epFAopFhs2BglIkGQ6CcnJykWiykW3rHGy8vLZRKRtt38/HxZyUqJ3uzLtSF6s8XHxubixYvU1dVx4MABMcGZ5NLrrrsOgLNnzyb9HHAj7WBEyNamr69PTNrGprW1Vdx2pVKJxcVFurq6aGtrExO9UfSmHInza+YTswSWajN2hLXn/0F5S+KxyVrRfGLKMfc1tb39pYB33wlffAT++sHNn8fB9B/jMKcSfSByMLMojxysrq6yvLzMwYMHqaurSyd6xwjF8rKX7NPU1ARsKHrRbqtdQEb0FYIZMH19fXR2dorIZ7rlPwC++p2VrXsaojcDUxoumpiY4Nprr0UpZUUIPT099Pf3W62VmskTZKrHXNOhQ4fQWotsgs7B7OwsKysrYpuDBw+itRY5ISZENzIyQk1NjahuhUKBpaUlurq6aG1tFRP94uIizc3NVoSwtLRUtrl48aLIeZmfny9nCy8tLYnCqAsLC9TX15cPB7EhU5swvLEZHBykublZ1O8MibS1tYnD4+aaTdtJowDAJtKWwBB9d3c3a2trovYOKu3V1dXyGEnCZOvLyq/Hl7tEUa5gdAcERO8vBSz5Cb3S3StmHJm+kBoR8iMHX/oOdL7V31kjiByYdurq6mJ4eDjdIfXLuTAHv/8F/9ApQTmmLwQV/erqanmO2WvIiL5CmJmZoba2lsbGRnp7e0WEEBxka2trosEcVvSSEKohz/7+frq7u8VKxISFbRJN5ufnaWtrK2dAS0hudnaW2tpaRkdHAdkaq5ncjVqU2JjJxibT2hBPW1sbPT09osndlGPaQUr0QdJeWVkREYJxDvr6+tBai8oK2oCsHRYWFmhubra6r6Yd9u/fTy6XE/W7sNKW2ASJXtreJvTa3NxMT0+PuN2CNraK3qbtzNxwww03ADInyfTNa6+9lsnJSdHZ68E1ehA45ofvQOcay0f5Svfeh4k+9Xr8CMFnHvDe3vnvmz+PQzAbXvRUOf/v/eyn4L98Eu4SlhMm+oGBAWDvbrHLiL5CMJO0Uko8CQTDcyDrJC6KfnZ2lvX1dfr6+qyVSGtrq9XaolH0NpPazMwM7e3t9PT0iG2C6hxkbbe4uIhSqhxStyFtGxUXJCsbojcEbNpB0oeWlpZoamoqR1Ck12RL9Gadua2tjXw+L7om0w7t7e1iBzPYdlICNkRvbCTluJC26QvBqIsELkQfXJoCO6K/4YYbKBaL6evteHNQbW2tfEyMHWHmOb/nrc0DZ2frREsECwsLKKUYHh6mpqYmvc/5EQJz0qHZgy+NHLS2tsqI3v975rjuf3ti8+dxiFqjh717aE5G9BWCmXAB8STgQvRmArjmmmu8JDmBjRlUvb29ThOUUfSSULIL0RsSsZ0Im5ubGR4eBuSKvqmpqXzAhe1arlTRh4neJmmrqanJiuiD4X6QEb2LQ2H6glKKrq4u0bJHuO1ciN7GxkbRB4ne1qalpaXqit6UZbPsEVbn0kiNqZt0WW+i0VtybGpq4tySbInAlJPL5WTLK35yoSF40RZaNt/X4eHh9FNK/QiFOQr6kdOycjJFbwGl1CuVUk8qpY4qpd4b8f33K6W+qZQqKKV+eDfqKEWQ6KWTgIvXbjzJtrY2urq6RAPT1KWnp8eJ6Pv6+sShZBeiN21nS/QmCQ3syMpW/cLeV/S26twlDN/S4h0WI70mF9IOqnOpk+QSug8T/eLiYmqex06G7hcWFqitrbXKiTB91SZx1EQi8/k8XV1dVpHIG264gfHxcVHybLD/iIi+vJXYo6gL81C46aOiyAF443VoaIjV1dXkyIYfoZj3b/2JSdmW5eXlZWpra6mp8c7YMESfKfoQlFJ54CPAq4DrgR9TSl0f+tkp4CeAT+1s7ewRVvSTk5OpCthMHGZtWqrGgPLkLrExE6EJj9tkGBv1AjLiMUTf1tZGTU2N1ZqxC9Hbqt+genFR9LYEJyWe9fV1CoWCNdG7KvqWlha6uroAOfE0NzcDXqKTC9HbOkmuzsH8/Dxra2uJNmHShvR2CCfwLS8vlx3vOGittxC9TV9tb2+ntrbWqu1sthmaKBLII5HB/AGttTiaFiR6iU1x/+uZXtR+/glMNN8mKge8ezQ05J/KmEK+JkJxww03MDlXYrHvB1PLWVpaKqt58A7Oqa+vzxR9BG4Bjmqtj2mt14C7gdcGf6C1PqG1fgRIzyrZZYQV/fr6eup594uLi9TV1dHb20s+nxcrOLDLFjYTgFGlkuzs5eVltNabFLAN0ZsQr42ir6+vp7m5Wbwlr729naamJhoaGsSKvrm5mZqaGrq6uqxUkmmH6enpVAUTJvrZ2dlUm6ADZ9Pe4WiITei+o6ODXC4nam9DPOApepsdC9sJ3c/NzaWSdtgG7EhbSsDBviB1xtbW1igUCs6OlVJKTMBhRS/p30bRA2JnLKjoQaZig0Tf398vqtv09DRa6/LBU9I8HKB8EiGkJyyburzgBd5DjiTXs7y8XJ7vAZRSe/rQnN0k+mEgeJTXGf8zayil3qqUekgp9ZDNQSiVRPDGSydqM+Hmcjm6u7vFoTagnN1vq5J6e3vLp4IlIWpSk0YPzGlRNmFU03ZSG0P0NsmPQbKSRkPCJCJpuyjiSSPGIPG0t7eLHL9SqVSeqI3zYpOMl8vl6OzsrGroPpfL0djYWL5HaVGu+fl56urqqKurE5N20PmVRoW2q+ilRB8cRzU1NbS3t1vlrQBWDn1tbS2Dg4PiiFVY0dvsFjJELzlTwTp0z0bbmnIkRB8O3YNA0ft1MeVI2mB5eXmTooe9fWjOZZGMp7X+mNb6Zq31zYZkdxrBUI6UGA3RGxupGmtoaCCfzzsTvaRuLuqlWCyytLRkTfRBVSGNAoTbzkbRg3zydHF4wslhYEdWxvFLuyazpmwmaps95KYdpPcoOFHbhO5NAl9PTw+FQiE1yhUsR9rvVlZWqK2tLbebxMZF0UcRvc04AjvnN9hXpeO8tbWVmpoaOjs7xREh2zkofBCSS+hecn6DaScbog/eI6miN467SXyUtEEU0Q8MDIhPp9xp7CbRnwX2Bd6P+J9dkgiH7kGu6EHuTYdzASRh+O0SvTRCESaeair6lZWVTY6VTTIe2E2eYKfiwqF7sFOLILumsI30mrZL9N3d3SwtLaUmrxniATvSDjvMafVbXV2lvr7eymZxcZFcLkd9fb31PbJxfoNrxmDX3sZGGn0y22FBPiZcc4vy+Tz79nnTtwvRQ/rSgnEKbZKVzTa+xsZGmpubaW1tTbUz49U8SEkaWQ0T/cjIiCi6sRvYTaL/OnBQKTWmlKoDXg/cs4v12RbCAwbsid52kjZh+LSwcDAcakv0JpRcU1OTamMm/oYG78lyLorehuhNOTahe5fJ06hsm8k9n89TX19vHRa22blhogA2yVTBNWOQtbfWeotzAOnLEa5EH7yvtjY2pG3WwKU2wTFhUzfY2IZl4/y6hO6D0RCX+aRYLKYe3GXGRF1dHR0dHVbb+GCD6NMcBEPAPT09dHR0iEP35r4CDA0NiYneHKQlDd0H1+gB9u3bx+zsbPnv7SXsGtFrrQvAu4AvAo8Df6W1fkwp9WtKqdsBlFLfrZQ6A/wI8EdKqcd2q75piFL01QjdRzkUEtI2E66Lopeug6+ueqdohIleohBcFL0t0YcV/dTUlCga4hJKbmhoKLebxKZSij5t0g3bSNp7ZWWFUqm0KXQP6cQYnAyl7RBU59KQ+urq6hait3Gy6+rqaG1tFdnU1tZSW1tbTmSUEr2t8xteZpqfny+PrzgEHSuXCKHNvBVMrLNV9NJzLFxOSQzWDbx187Rw+vz8PA0NDbS3t9PQ0OAcujdbIav1xLztYFfX6LXW/6C1PqS1vlprfYf/2fu11vf4r7+utR7RWjdrrbu11jfsZn2TEJzUWlpaqK+vt1b0EuIJDkxpCCxKWdmuLUqIJ2pSW11dTdyCpLXedE3d3d1MT0+nHt8ZJnpJNnyY6CVHxrqQlYsqDa7RGztbRd/X15e6lONC9FHrzCALqVdCnUtsjHPQ0NBAc3OzSNEHCUGydTJoI82jMOQcdF5sFb0Z5zYOvauiB1nEKhgZszlC2dhA+rwVzo+xdeZBrujNTiGbJY8w0ZulDOnjoncSl0Uy3m7DkJW58abD2HjGvb29lEql1IzuqIEpSQ4zE0BdXR3t7e1ORO8SuodkQjAnTAWJp1QqpT4cIopEkkLJxWKR5eVl67YLEk9DQwMtLS1WZNXU1ERjY6Ozok+KhkQp+rSlnKg147T19vBxn9LQfZCAbRS9abu6ujrRU+KC7W3qJyHtYOhVQtpBhxRkzlgU0c/NzbG+vp5oF1b0IHPog/NJWv8JO9nVUvSFQoFCobAlEmmj6F2W58BT9GlPlQtHQqSKPhy6N4o+I/rLFKurq2itN914SagpHLqH9EHmEroPdmRjZ0v0kusxZBEOvSZNumFVKrEpFAoUi0UrtRh2KKSTTZB4TFlpbRdlIyX64KRbLBYTHZ6oNXpIbocoRQ/JpB1ekpGG7oME3NraSm1trZU6BzmZBm0kpB0OvUrGRLgc1ygXyLZbBsce2I1zyVkea2trFItFa+fXVtGH26ChoYG2tjYR0Qdzi1wU/eDgIMvLy4njKNhu0ohLVOjeHMedhe4vU4QnXJBP7rZhs6ikqGoQvUtymIuiD4esJSQSLkfSdnE2EkXvMrm7EkI44zzJLqy0JTbhclza2yZ0b9pBGhYNq3NJSN3FJkzakjERdV8ljiLYOb9ra2usr687hbptkh/D85ZNPklQ0U9NTSVGKML9B2Sn44UdF8mjm8OKXrKXPthunZ2doqeIhvsceBGo/v7+TNFfrogieimZ2nrTQUVfW1tLZ2dnVYg+PDh7enpScwhcCCHsUEhsouoGdkQvXfeMIhEXsrJ1kiTXFFbaNu1gQzxhsjKnEUpC98F2qJZqjlL0tkRvlGkSkYQjNSYsnFYOYLWEEbUkA3ZKW2ITLqepqYmmpiZrRZ9WThTRS07HCxP96upq6t77sNKW7KUPltPZ2Sl66l+4/xjs27cvU/SXK0xYOEz0SR25WCyysrJiHboPe6zSMLytzerqKjU1NeWHNkhyCKKy7sEtdJ9EIpUgRWk0JDy5S5cwbInehRC2Y2Nzj6ImasmhOa6h7vB6ezVsou5r2oObwtczNDTE9PR0efzH1Q3c2tuMCcl596VSibW1NSt1HidQbBU9JG+VC/c5kIX8t7s9E2SKPlhOR0dH+ejdJKytrUUS/fDw8J7cS58RfQUQDqGC15Hn5uZit8REJV+BLDvbxqEAr/NHDeakzhwVpkyrX3hSk4SFK6HoJdnZYSUrPTLWdc3YRdHn83ny+Txgd0027eASSg7bGDuXkHo12i7KoZiZmUmMPkUpekgOj0cRPSSTSJwzZtO/zXn3aXUL2kiWs+KWHF0UfVLd4kL3NkTvkoP0U6sAACAASURBVDwLsufEhxX92tpaYnKq1pq1tTXq6uq2fGfzdNCdREb0FUCYRCA9pBWOAtTX19PW1iYK3YcdCpfw8/r6emKCSlTYFezI1OxPlkxq5pok+5PDE0d9fT2tra3W4UPpEka47RYWFhIngijnYGZmJnEdM0xwNklypixzGpiLcyC5R2Gitw3du+Y3SNo73HZpzySIWqOH9BB00MYkXyWFheMcK5t7ZOpn07+NQ5FEpuFnqkvKAXtFH0f0k5OTic5YJRR9a2srzc3N4tB9R0cHQGLfMeM4StEbEZW2PXinkRF9BRCleNI83TDBQbo3bbLNbQdmHGkn2UUpqzSbqAGdpvzCbWdOoJOUEyaEtOsJ1026hOHSDlE2aaQdvJ62tjby+bzVEgakh62jnIPGxkbRPapE6F6S5xHVdmn1CzshkB7ZcFH0UWHhJBIJ3yOz3dJ2qcSW6FtaWmhqarIOqaeF7guFAqurqxVR9KVSKbEdKkH0kLyX3jxGOKjogcSEPNNucYo+bbfMbiAj+gogbsBAOtGHVYXN+qqxuXjxYqwHWSwWWV9f37Z6qRbRV2JSg/TIRlx7S5Y9XJYwosjKxkYpRWdnp0jRByecNNXsEoZ3sdFaR7aDrdJ2aTvpcoTtmIgL3acp+lwuV851MfWzVfRpoW6jzoPh/oGBgcRjY6PKSXOYg+f9g6eYGxoaRIo+2HaS0/HCB1yBfegekpMmV1ZW0FqXHReJojePTY5T9JJ67jQyoq8AtqPoXQguPEEVi8XYjpnkhNioUqlNuCwXEkmb1OLazmYN05RjO3FIsoxdyCoqizdNNa+sbDy1LViWLYmkheGT7mtcnkdUeDOtHbTWsREUG9J2sZGcqxC26ezspL6+PpXow/fV5R65OL9Sog+3w+LiYmyCYTinRinlNF4lkYDgoTRtbW3U1NQktptJSIxS9HH3KFy37Sp6aVL1TiMj+grAheijiMc1/AzxHStu0kiyMWUFbcw6uG3EIW1Ps4t6cSHtuHZIioYYu+06Sa5En0bA4XtkytoJRd/V1UWhUIh9gEecWoT4djBKabvREJfQfXNzc+rWsnB0RynF8PBwaug+fI9colx9fX3Mz8/H5ipsh+ht2jtqyTHtdLztEH34tNGkexrVfyD5dLxwnkKlFL3kcJ+dRCLRK6UeEfy7b6cqu1cRNRG2trZSX1/vFLqPU0lxNmAfOQA7sjJ2thGHnVb0tm1XKpViydQoTJdlj+2SFXhkarOub8qySZg05dgST1qy4HZIxGa9PeoepYXuo2xA5mDaqEVjY3uPwmF4cHPo04i+UsKhGoo+aunHJaoBHtEvLi5GOqXhtq7EGj1ceoo+D7wm4d/tQG81K3gpIIqsTEjLVmkn7eWt1MCUHIwRVi+QHnFYWVmhrq6u/IhI8CbdmZmZ2AfOxE0CMzMzZc9ZapN05KdL20UphI6ODvL5vBXRuyhMkBFwlKKfm5uLbTtzPoLZxmfq57JGD/FkGmUjJfpw0l+STdQ9amlpoa6uLrZucYosjUii7pFENUdFalzyVsCe6KempmK3+CaVY3OP0hR91Njr7OykpqYm1m59fZ1SqbQlWdl2yQOSt0FG7fqBK2+N/m1a65MJ/04AP70D9dzTiJrUINnTjQtzQ/pgttnGF1UOyLzjStgYQkjLIbC5pqQJqpKRjSgbsysgSYmED9OQLHvEEYKLoodkAo4rJy0aElQwaUSfFAWIa4eovmAeCZtmE05kTEp4cxmvxi7KGXNZXpmeno7dfZCkgG36qtlDbhNVlM5BUYo+bgksbhwl5dXERYRciD7pdLywoq+traW5udlZ0Tc2NlJfXy86XW8nkUb0L1JKjST9QGv9lQrW55KEy8ThQjzbcQ5sSTtqgtoO0acpv+CgcSFtafKjTRjexUmKs5GsnUeF7ufn52P338dFXSCZgKOIPmlL0OrqKnV1dZuS/lwUvYkk2ahFc0024X5TP5u6QfJ9LZVKW3avwAbRxzlJcc5Y0u6DSjmyAwMDQPxhMdtxfsNr9IVCIZYc4+6rZH602UocV45ph6joQVQ5acfgJil6if1uII3oh4CvKqW+rJT6aaXUFR+mj8J2iD6KeGwmtbTHzroSfRQhGJsk5WdL9KacYLjfZceCS2TDxTkwdrbtLSH6KBKB5GhIVDmQrJpd75GtDUS3g4uT5FKOLdGb+xrVv+Nsurq6WF9fj11uSxoTNg6PCwEbgotbWoi6JrM0ZVM3M47iwvBJRB9nE5WnkHYOQ1w5SYf6RJVjjsGNQ5Kih0uQ6LXW7wb2A78MPBd4RCn1BaXUm5RSrUm2VxLSiD5q4khKVqokaSfZ2CaHpT1YwoVE4pKiwC0MX+0wpSkrjaxckuSiFD3YtZ2E6G1JOy7akGQT5yS5qPMkm7j2loTu4/q3eUSzxMa0Q1z43mV5JarfmfPuXRR9HNGb7ZnBfI1cLkd3d7fVmEjbE29samtrN31u6zC7REIgOR8gTtEnhe6dFf3xu+BvRuFTOe//43fFllFppG6v0x7+VWv9DmAE+F3gZ4DkZwxeQYg6FAO8jryysiKeOLYTSraZAIyNS+g+qX6uij7K008rJ9zeEqIP7zk367+VDN1XUtFLMtttFX2SOk8qJ2xTU1NDe3t7qmp2CcNH9SEXG1tFbzKuoybpJIcC7IhequiDitGcd2+7dg7JRB9FVrb3SKLoGxoaNkXtjF3ceI07nhfsHXOTD7Criv74XfDgW/ntvzrJXf+uYekkPPjWHSN78T56pdRzgV8DPgKsAr9YrUpdaogazJCsTKM6ZWtrK3V1ddaKx1XRLy8vW4UcJQPNRS2Gbdra2qirq0sk7fDEUV/vPSsgKfkxfD3mmmySH41N3Nn1rkQf1XYuil6S8OYSdYlquyQydWkHl2hIEgHHrZ0nheEhmujj+oIkshHnjKXZhInRdpzX1dXR09OTSPSuY8JW0UeV09fXx8LCQvnhOmnluOzaCNZxVxX9w+9jfmGJn/9LeMMfgNZAcQkefl9sOZVE2j76g0qpX1FKPQbcBSwCL9daf4/W+kM7UsNLAHFEb4gxqYOFt+S5JHq5Ej3YkbaLom9paaG2ttZqIkw7bStOiZgDcGxtXNsuasJJIrikh7MkhceTQpXha6qrq6Otrc1J0ds4FMbONnSftGSU1HZLS0tiQjB1KxQKkdst0xR9lDpPcw4qrejjiNE2cpe0/W87zm94N0Uul0tV9GEkRe6iFL3LOQwG/f39kW23Y4p+6RSPBR5TPzG38flOIE3RfwGoB16ntX6e1vo3tNbHdqBelxTiJsIkzz0u3J+UrJSUHBZ30I4L0ZstYpUIw5utTrYkkrQcETdBpSk/20ktzrFKitQkqVKwI1OJondph3A5HR0dKKWsnSRJeDyKtOP2+SfZQPw4gviQepRN3DiShO4rsUbf3NxMfX29NdGnEbBSass6eBLRVyp0n8/nE7ecphG9NOLpmlMD9op+bm4uNulPouhnZ2c32zft53Sgi5y4sPH5TiAtGe9qrfUva60f3ZHaXKJII/o45RcXnrNNIurt7aVQKCSGHG2IPq6c7YR4XdSLrUJIm6DiynEJ3UN02yWpUrBbO29vb098gl0SAds4PPl8no6OjqqE7m0cnjQbmwhK0tp5Jdfok6IApn5Rzm9aXw0Sj0Ea0buE++MciosXL0YSnUsGfVz/SSL67Sj6JKIPi6GocsyhOUnbTSFZ0W+xP3wHp6c3nLBTF4F8Exy+I/JvVBppofu/S/sDkt9cypibm0t95GCSZwzJRB+G65ox2BGPi017ezu5XM5K0UO68otT9LakneZQJIXuow77qGTbJfWFYrFIoVCIJISkJ9i5KHoXdV5pRQ/2yx5gp+iToiEuRB839sxjfm0UPaSH4eOIMe68++Xl5Yo5vya7PeqalpeXIyMHcaHxtOuB5KXNoF1DQwPt7e1W5wIE67e6urplKccQffAepR2DK1H0EOpHY0e40PzK8tuptS645WMwdiTyb1QaaaH7W5VS9yT8+1vgetfClVKvVEo9qZQ6qpR6b8T39UqpT/vfP6CUGnUtywVLS0u0t7fzkY98JPF3cYPZHMUZNdCSogCuoWQbdS5R9OH65XK5xGNZXYk+brKxLSdt73ScY1UsFiMH9XaI3kaVxrU3JJ+8ltSHbJcwXO5Rd3c3c3Nz1kmJYNcO21H0NkTf2tpKPp+3UvTgdo9clTbE97s4m7jE0aQxAXaRSJcIXNJOmSilDTAyMsLZs2djy4F4ooetTkXU9SQ5fCBX9GH7qdJg+bn30wd+bsdIHqAm5fvXCv5G9KHaKVBK5fEy+F8GnAG+rpS6R2v9ncDP3gJMa62vUUq9HvgA8DqX8lzQ1NREb28vJ0+eTPxd3GBOCtEldf7Z2VnW19e3eM1R28pAttYV7pQmw99GlULlld/Kygrt7e1bPu/p6WF+fj6ybZOI3jxiMzxBSCZPowINktZlc7mclWNVDaJ3WWNNSqyzXcsNhsfNRBq0gcqStk3buRC9Uio2ESvtHtk6pb29vTz11FPWNuD11X379olsgu1tjoIN2iQlEV+4cIHrrrtOVE6aoo8qp7m5mebmZvEaPXhEf+bMmS2/T7Ix9QOP6A8dOlT+PCoSYkL321X04XE7PT3N8PAwx44d2/EDddLW6P9V8O+rjmXfAhzVWh/TWq8Bd7PVsXgt8Of+678GXqrCrmSVMTo6yokTJxJ/Ezd5QvykmzaY4yY1F08/fPIcJGf4Jw0YF6Wd9Oxyl0TGtEktziZtUouygejIRtyhInFtl/RwljjnwNhFEX3Us9sNgg5PVP3iSNt2icAlPG7uUVIiY7iszs5OlFJWzoFLBr2xs0nGg3hHNu7YXEjPDXFJXnNV52G4LDmmbZWLsjF2too+jejjsu4hWtGHy5Aq+rDgMojbLTM1NUVXV9eunJy3m8+jHwZOB96f8T+L/I3WugDMAt3hP6SUeqtS6iGl1EOVfmpQNYk+ieBsw3NgNwEYOxuCg3R1HjcRrq+vRx4cVMnJJk01uzhJED25x03UcTY1NTV0dnZat3ecWiwUCpRKJafdHpWM1MSVs7Ky9UmGwboltUM4+mTazsZJSjrQx4Xo0+5RlEOR9pSzxcVFK2J0Cd1vZz6xsUnaS59G9NI1evCI/vz587HLReFnMgTLga1En6To48jYPLQqTnPGOQrT09N0dnamPgipGthNoq8YtNYf01rfrLW+2XTSSuHAgQOcOnUq9nx3SCd6mwk3TdFHlVNXV0dHR0fFiD5NvUTVLUlhpoVRK5XI6KpEwC6/AdycpLgtPi6KPskmrR3iSHt+fj5225vLfY2yqampoauryyr6ZK4pSdHbOKXbUfQ26+1JjqLrejtUTtEnRYRs65aWWJdE9HHl5PP5LcuXIyMjaK0jE/Lirge8a1JKiRS9ZHdR3Po8xBP9/Pw8ra2tV5yiPwsEF5pG/M8if6OUqgHagfgHOVcBo6OjrKyspD5vOamDuYTubQaZsaukDdiFKY3CtCWESpJ2WjkuERTYekY3xO/zTyLguHXMNLKKSnhLIp60yEbaenslbOLaG+LDta4OM7gRfdQ9ciF6U7fwzo0kmyQHM65/m/PuK6nOo+pWXx//WOU0Re9C9HGh+yib4WEv6BsVvk8qp6amhp6eHpGiT3vKYvgx1GHEPap2cXGR5ubmvUf0SqnXKqXeGXj/gFLqmP/vh7dZ9teBg0qpMaVUHfB64J7Qb+4B3uS//mHgX3SStK4CRkdHARLD92kTVNQTl1xCbUnlxA2YahD9ysrKlpBjmg3srqKPc8aSjs6NyzAGt7aLC1OmJXrB1sSgJOcgLnQft40P3JwkFwcO3JzSJIc5/AwDg7RoSJQqc1mj7+3tpVQqbblHaVEAsCP6tLyaqL33pv9UWziYRD9bpd3f3x+5vTWunJER76nptkRvygqP87h2S0toTVL0EN2PDNF3dXXtLaIHfp7N5FsPfDfwEuAd2ynYX3N/F/BF4HHgr7TWjymlfk0pdbv/sz8FupVSR4H3AFu24FUbBw4cALZH9FFPXEpSSUmJR0kD04XoTWZ7uG4Qr5Jg6+SepkqjbJLql5a8ZmvjuoSRZDM1NUWhUNhSTtTOCHAP3cNW1ewSupcozHAfSlqSSTreOKntkhR9pSJjEK/ok5wDM0GH9YTEsQr3IUno3mXM2tiYpRLbtrNt7/7+fpRSkUSfpuijDvuK2jkDG0R/+vTpLd9JiF6i6CGZ6NMUPSQT/Z5T9ECd1jrYol/RWl/UWp8CmrdbuNb6H7TWh/wT+O7wP3u/1voe//WK1vpHtNbXaK1v2Y3jdw3RJ22xSyN62DrpxnXKfD4fu4aZpuhdvHawm6DSiN4mfGiO2o26ptraWtrb260mm6SEt6S2SwqpJ7U3bG2HNPUyMzOzxbFKS/SCrUQvsbEhehN6DW+xW19fR2sdu300Lmcjqe2S1GKcjSknTMBJ9zUpdJ+0NapYLG5JHHVZKql06N7YuURDXBxZm8hBbW0tvb29PPvss1Z1i3Mw42w6OjpoaGiwdiggmuiTFH3SeSa2in5tbY1CoUBzczMdHR3Mzs5GHtJVLaQRfWfwjdb6XYG3lc1626NobW2lu7t7W4oe5ERvbFwmgMnJSfESAbgRfdL1xNl0dXWRz+e3DLIkVWrKsiWRJNJOIuCoPeRpNhB/AEeSTbh+ktB9lEMB0W0Xl6WeZGOeXW57j+LaO03RRx2xmjYm4paMkhT97OzslqhLGtHD1kSq1dXoZ1OA2zhqbW2lvr7ean3alOXi0If7QrFYjN36Z2xsx9HQ0NAWAk6KCEE80ccpeqVU4rn1e1XRm6eENjc309bWtumznUAa0T+glPrP4Q+VUm8DHqxOlfYeDhw4UHGiT/OmXcLPpVIpUvnZEr1E+cWRVVRZuVwucn06qRyIHmylUinygTsGUQ/xSLNxmTgMMYbLclEvaeu/UTZJih6i2y7JpqOjg7q6usjrSSonqe2SSERrHem8uIyjOJu4/cyVtnFR9Iawwu1dKBRi8yjAfYkubown9e+JiYnIJYw4m8HBwS2KPm2Mx80naQ6zK9EvLi5uItg4h6LSa/RBojen40U9WbFaSCP6dwNvVkrdr5T6oP/vS8BPAD9T7crtFaTtpXdV9LahzbTQPUSTdiUVfRLBxdlA9OB0UfSSCSpct7STrAYGBrh48WJkZnuaOo9qh7RJLSoKEFe/OBsXJ0lCPC6K3jYaYhuuhfgEwzRFH2UjUfQ2DnPcGn3aPRocHNyigNPa2xxMY/qMtH42Yxy8+7q+vr7F4UlT9GGiTysnaX97FAEbG1tnB6LHUtJuhbinLFZK0e8ZotdaT2itvxf4b8AJ/9+vaa1fpLWO3292mWF0dJSTJ09G7qUvFosUi8XEdULYmdA92E2eLkTf1tYWuUbmQvTbUaU2RC+pm9Y6sh2SnAPYSvQS58CGTJuammhtbbUm4Ki1c0k72Cr6gYGByKeCuTiYacl4YKfot0P0Noo+bjtWWntHEX2aTdKYTYsQBu+RxIEDu4jV0NAQExMTm5ZK0q7HJB/vhKKPciqSFD3E7xSSKPrgo2qjFP38/Hzi36gk0rbXNSilfgb4T3hn2n9Ua/0vO1KzPYSxsTGWl5etnj9u0NTUtOU857R1q6iBacpKigJA9AQQZ9PR0UE+n7cieqVUIpnahHhdVKmErObn5zeF5yQ2YLfe3tLSQnNzs9VE6KLojV0lnKS09jakbWMT91QwSSKjTV91yXWJ2+dfaaKH6OU2F0UvJfrgfJIW7u/p6aFQKGx6CqfEgQO7MTE4OEipVNpUt7TriXuWfZKiT9qSl3SPbBR90lZdqaKHjW2xe1rR450zfzPwbeBVwP+oeo32IJL20qcNZtg6USdlMkP8E9VcFX3cgMnlcpHRg6TEI/AGtGvoPui8pNn09PSwvLy8KQFLouhh82CWEFzYxtglKYQ4hyfJ6WtpabFKxoNopS11kqJUXFI7uNxXsItsJOUdpJG2yxp9tRU9REfhJEQ/NTW1aReGNNQdLEsSOYDN96gazu/Q0BCweS99WuTAlGWr6IvFotUyjrGDjWsqlUqppwPGbe+VKHrY6EdRRL9nFD1wvdb6DVrrP8I7sOb7d6BOew7bJfqwUpKoMYgObaaFKaM846TOH5UPkDZgXBV9WPlJyArsJrUo0nYlK4lCsFH0EH1ojiSMGqfobbLUJe0wMTGxSSm5OklpW+WUUlb9u6Ojg1wu56TobYg+7lG1affVZR3chYCjIndpNoaAg+vnkvEarlta5MBcT1Q5aWPCZt5yWaYM2pm+aurW1NS05beVUvRRRH/ddddx+vRpXv3qVyf+jUoijejL2Un+ATdXJJIOzZEq+qjBHKe0XcLwNTU1kU9US+v8rkQfF3JMCrdBNAHbZORKiT7Y3tL1SBv1AtF7mtOiAEmkHacSXELqUROVhLTDSqkaa7n5fJ7u7m6ridqcL2Gj6Nva2sjn81ZEH/eoWkno3kXRw2YF7BK6lxJ98DnuaeO1s7OT2tpaK4c5StFLiV66vx3cx2tdXR2dnZ1lO+ME2xL9dhV9XV0dIyMjqc5CJZFG9IeVUnNKqXml1DzwvMD7nVtg2GUk7aV3UfRxj2A0SNqGFWdj7GxyAaJsTDlp13Px4sVNGakuoUDTdnHX5ELaUTZpDkVzczMtLS3Wofs4FWdL9Kurq7EntRmbqampTbsCJDsWIJrobUhb6oxFXVNSH3JxkuJyNuJs4g70SbtHUSeX7RWijzrvXho5iFLaSct6YQKWjHGllLWijwrdp63Rgz3Rh8tKmodNNCgqKXq7in43kJZ1n9dat2mtW/1/NYH3bTtVyb2A0dFRjh8/vuVzqaKfnJwsT9RpRB81ARQKBYrFYqo6Dw4YyfpYlFqUKHqIVhU2zouLOpeErJVSVjYQH4aXJGCF8w5s8jWMjWRtMartbBS9SwKWJLs/6jAkSSQpStGnrYPbnEQI8Q6Fy3p7Wl9YWlqyWipJUsBx48icd28zjlpaWmhra9tEwGYOspkb0sqJOh0vrc+Bd4/m5uY2bRmU5CMF66a1FhO9RNEnncwpUfTh8xjMSYt7kuhN1r1S6sP+M9+js7OuAJjH1YaRNjBhKzGmDbLe3l5yudymCUAyMMOTmoTgBgYGmJub2zJBSYh+u8k90sQjm3Jqamro7e21igKY+tmsM0N00qQk3B8+wTCNRJKiITb5DdLDS2wUfT6f39LepVIp8dQ1iCZgyTq4zXkUEK+009rbdv03arktrb2jxrlkzIavSWIT3uPu4vxK5xObMW7KgY350eQCxM2p5qTN4D0y0UUbok8TXHGH5mxH0Uc5FTsBm6z7VwMfrHqN9ij2798f+Vx6m44cTgKJ62D5fJ6BgYFtJ7VIB2awbpCukqIiDmmOSNTzoNPqV19fT1dXV8Umm7TliChFn+TAxZFpWl/QWm8Jqdv0H1M3pVTkI3TBLWnLZceCqV9Ueye1XViVmifrpSltmxMmwW1pKm55Jc2hgK3tXVNTQz6fj7QxTpItMcY59Ent7UL0LsIh3HZGQCTVLexgppXjsqwQVb8kRQ/xRC9R9OFH1S4uLtLQ0BDbF6oN26z7F+9AnfYk9u/fz+LiYmQ2LsjI1HTkNE8Stu6xlXr6wbVcGyckTKZppBhlk8/nY7fkRT0P2oWAt2NjM0FprRPXCWFjcg+Hx1328tq2tyGeqEfoQnQyVRppt7a20tDQUDHHKi2fJPj0P0nUJerBNtVQ9C5RlziiTyMeF+c8LnSfVL84ok/r3xcuXCi3t8s4MnNdkpINjwnJ/BjnXKYp7b6+PmZnZ1lZWUktp7u7O/IxxxJFD5tzPcyT63YLWda9EPv37we2Ph7RRTVLwvAuHrgpx0w2Lk6IsUubCKNskgYmxA9Om61827FJI+DgMbiSUKDL5B4Xhq/UQR8GUWeppxG9OQzJdgINlyPp32EnSUL0PT09rK2tldc7pcmmMzMzmxJHJe1dKpW27D6QjAmb6I4pK0japu3SyoqykSh6Q9qSe2S2aJqws024P1yORNHbEH2copfMQeAtE6Qp+q6uri05IYVCgVKplKro4dIiepN1P3clZ93DBtGH1+ldVLPNwLQpJ7xfdjtEn1S3uJC6TdgM5MmCrkQfnmySVEVcHoUkdG/ISko8wXLMNSXZmIN2bJwDc02VIm2JurJRfmFilNQt3N5pzzCA6KiLq2NVLUVvq4D7+vpYXFwsE1UaYYE3N6ytrZUVqjRyABttJx17Kysr5cNgbIheGro3NrbOTrCs8fFxJ0Uv6XMGlwzRB7Lu2670rPs0ok+68Y2NjbS1tYnX6MEL3V+4cMEqDB/eRiMdzOEs9bSQNWzdS592MA9sT9Hbhg9XV1fLR366qAqbidBM7pIogIuiN3Y2xGNswoo+aRsfuDtWa2tr5fa2IXozWUtswuePuzgUxhmTqPNweyf1n7a2tshtb5JQcpCwJKQdFyF06d+SpSmbCGG4HMkafX19PR0dHU6he5vIQbh+aW3d3d3N3Nxc5LbWy03RZ/DR29tLfX29k6KHzZOuNHQPdl6ui6KPylKXkHb4GFwXRZ+WUAbepLa0tFQO10q3BYFdBMVlImxqaqKxsdFKlba3t1NXVyd6sEa4fjbEA1sV/dLSUqpNOAFreXmZ+vr6ROcgTpFJSMSQnCTpL6zoJTbhciSKzHWpJCobXjImFhYWyqQj6d/h9pY4B1Hh8aRjrmFrsqnkvkaVU1tbm1iOsbNxssMnbW6H6JOy+2HzsxJsFb2xzYj+EkEul2NkZMSZ6IOTrjQZDzYy26WdP3hghU3dbNfbw4peukYffB60mQjjEspMObCZtJVSVslrrjaQ3nbBh5lI2jvqcbASAo5KcpLYTExMlJPKJDaG6M0xuNLoDtjloMSF7iWK3qa948qRkJVxDorFIuvrYf1exAAAIABJREFU66nt4EL04cjG0tISDQ0NqVEX2L6iTxt7LqH7qGXKtHYzdjaOeTjqsp3QfZKih81Enyn6KwD79+93SsYD+47sqs77+/udiD4chpeSiIFUvcDWySatbrBZvTQ2NiZOUFGqIm1Sc1H0sHlyl+QcQPS6bNr+2rAzJiXg4JG2UqIvFovlCUraF8Bu2aOzs3PTXmhJNCR8WplkHIUVvcSmo6Nj044F6TiKOrDKluht2jus6F2IPglxil7iMAdD9xKijxJCNnvvpUTf2NhIa2vrpmS8NEUfTMizVfRzc3MUi0UWFxdpaWlJtakWMqK3gNlLH4SLordZb7dR9LA5iU+qSl1Iu6+vj6WlpbI6l67Rw/aIXkKKUeuEaRNAOOFN2nbBvbbSLT5RiUQSAg5uR3NV2mltVwnikThJuVxuEzFKktA6Ojqoqakpt7eUtGtqaqwiB0qpTc6Yi9Nn7CRr9LBZ0Uv6Amy+rzU1NYlLYJ2dndTU1Gy6prRywnkHknvU09NDLpfbVDepordpb5dM/XBZae1WCUUP3qNqFxYWMqK/VLB//37Onj1bnmwhff+4QX9/P9PT06yurrK8vExdXV1ieK6vr49cLmetzoNEL7Uxk5rWWrR/3NjA5mQqqXqphKJPgjk5y3ayCapml8ldslYKbmH4vr4+tNZW6twljBp1X9NswsfgSp2kIJlKJurw8a8SG/Mo5nDkwCZiZbOM47JGD3bOWG1tLd3d3VaObPiQGYljbtrbOFaS/m2eL29zPeC1g3R/u/k9bI/ol5aWEusW9fRDW0UP3ul4GdFfQjhw4AClUmlT+F4SnoPN6koy4ebzeacw/NDQkHUUoL+/v7wlZn19nVKpVBV1HraRZJsbErFR9LlcbstSia2qsFH0LkQ/MTGxKWNY4lCAnWMVpehtiV5CCGESsXEwg0oW0tsuaCOd3IMJhjZRLltF39fXx/z8fFn1Se5R+L5KQ93h/i0lU5vxCtH923aZUno94PVVm3wN2/EKGw5mWt2iQvcuin56ejpbo7+UcPDgQQCefvrp8mfSARPuyBKbwcFB68lzaGiIiYkJ1tfXrYgevMnGZlIzNqZ+tiFHSTuESdtmIqx2+BC8iXpxcZHl5WUrslpfX7daBw8nle2UondJprLpdy6kHXYOJPfIVtG7OC7h7WgSEWCWjILtICHt8Jq2S/+W2IQVfVp+TLgcmzV6kO1vh42ohm3/CdYvTdG3trZSU1MTGbq3UfTnz5+nUChceYpeKdWllLpXKfW0/39nzO++oJSaUUr93U7XMQrbIfpgCHo7oWQJ0ZtybJQVbB5kLklEaTbmedA2qhQ2t4OLenFpb5twLXiZyYZ40jz3oNOX9gCPcDk2BNzW1kZDQ4MV0Xd3d6OUsib6qBwUF9J2UfQSGxdFb6Iutn0hmA8gFQHbcazSCCtoYxO6h61LU9V0QkCu6I2Na+j+4sWLTE9PJ45V85jjoKKX1g02iP7MmTPA7j25DnZP0b8XuE9rfRC4z38fhd8G3rhjtUrBwMAALS0tPPXUU+XPqk304TB8micZzNa3SQ4DuTcNbqFkU5Zt+DBIwDYKwSV8ODU1xdrampisgpnJNqF78NrORskaG5BdU3grn3TJKLimvZ3tURJn0ewht+l3Nln3xsZljd4cAmQT3YHNRC9RfsHogStp2yhZ6SNdYWvoXlI3kydUKpWsHHPYmB9Bdo9cQvemrKeffrpMxnHo6uratqI3RH/FKXrgtXhPxsP//wejfqS1vg+Y36lKpUEpxcGDB50UfVg1SwlufHycUqnEyor3JKy0pL/g6XhmT64k1AabQ/dp9TOn/QUjDjtB9DYTR1CR2agKm3aIUvQ2uwKkqrSrq4tcLmcVugc3hyec8CZtO9PetpGkCxcuWKnz+fl5lpeXrZykubm5ciKsTd22E+WymRtcok+Li4tlR0k6JoLOi1TRz8zMsL6+Lh57+/fvZ21trXxfJdcTbu+0w3zAcyjOnj0LyLbQGpjx99RTT9HR0ZH420ooepPTdSUSfb/W2mzcPg/0b+ePKaXeqpR6SCn1UPhJVZXGoUOHnBR98Hx4mxCY2QctLSeo6BcWFmhtbU21MWRlo+jBG9AnTpwA5Gt+rkRvHB6bNfq1tTVmZmasJk+wa4egopc+czo4qUnXmYPZ48VikbW1Naf9ydJJ13Yt1xyDOzMzw8rKCrW1tamP5AwS49LSEkqp1CSnKOfARmnbKHrYHEp2UfSS/r1//35OnjyJ1tqKtE39XMLjNk4feAlp0roFjwuXjteGhobyMbhmz3kaae/bt4+zZ89SLBbF1wNeUrVBGtFvR9E3NjZSV1d3eYfulVL/rJR6NOLfa4O/017qsY75MyJorT+mtb5Za32z6ZjVwqFDhzh+/Hh5m4U0PAcb4c25uTna29tTfx8M99t44Pl8vkz0Ei+ytraWrq4uq0kNYGxsjOPHj1MsFlldXbUmepsdC8bhsUlWAsqOVbXWCaNIO61+3d3d1NTUcO7cOSvHyqxPm8mmWtnZ21ljNaFXlyhXU1NT6uQedA5slz2CzoFLgmqaTXDPfrFYpFAoiNrhqquuYn5+nqmpKSen1MU5kM4N4aUpW6KX9jlTv/PnzzM/Py8SKPv27aNQKJTHq5Tor7766vLraip6pRSdnZ2Xt6LXWt+mtb4x4t/ngXGl1CCA//9E8l/bOzh48CClUonjx48Dcq8dNsKoc3NztLWlPxMovK4vcSjy+TwDAwNWRA8boVebtS5D9OYcesngDO6XlTpJ2yVtV7KSqNLOzk7q6+vLdYN04snn8+zbt48TJ05YEb1Zn7a5RwMDA0xOTlIoFMTtMDw8zNmzZ8vLHtXaVRJW9DYK0/TVtKONwzYu6lx6j5RS5TVt6SmJ4BE9wLFjx6xJ2ybnJ0z0NtE+szRVLUVv6jc+Pm5F9OCFxm0UfUdHR3leNHvl4xAmehtFD1z+RJ+Ce4A3+a/fBHx+l+phjUOHDgGUw/e2RD8+Pu5E9DZHKJpkGFuitw3dj42Nsbi4WHZ6JGUFlZJ0b6lLIuN2Q5vS+2qe4X7u3LnyRChZJxwbG7MmeqPobTOMtdacOXOGUqkkshkaGmJ5edl52cMm+gQbpC0hkbA6l2z3clH0RsnaKHpTVnCJQEIIY2NjgEf0Ln1VSsDDw8OAR4zz8/NVU/SGSI8ePcrKyoooegkbc9Dc3FxViR4oO/Cm7ePQ3d29aeusTV8Aj+iNc3BZhu5T8FvAy5RSTwO3+e9RSt2slPoT8yOl1JeBzwAvVUqdUUq9YldqG0B4i51U8cD2FP3CwoK4o5hDc2yI3qzL2nRkM0i+/e1vA3ZEb9bibIg+SKY25UgngaamJlpbW8uTp3TiGBwctKobwOjoKMePH7cmeltnzLSdyaWQKnqAkydPUiwWnaIhEpvm5maam5utFP12owDS/l1bW0tnZ+cm0pY6L7bOgRlHTz75JIVCQdSHzOOlbfpqZ2cnra2tPPHEExSLRdF4DUY2pP1bKcX+/fvL84KU6M38KFX04SUCG6J/wQteAGwItziEz9R3UfQGV5yi11pf1Fq/VGt90A/xT/mfP6S1/qnA716ste7VWjdqrUe01l/cjfoG0dXVRXd3d1nRLy4uijoleB15YWGB5eVlEdG3tLTQ1NS0LUUvdQ7CoXupogc7ojcT9bPPPsvy8rLIxpDVqVOn0FqL6tbV1UVNTQ3PPvusOH8APNI+e/Ys8/PzontkbGyJfmxsjPPnz5cTfST1GxwcZG5urhxKtCFgE3WxIfqjR4+KbYLHDksnatjsvEjarrm5mcbGxnJfldStvb29fGb78vKyaPcKbF0qsVlesVH0LS0t9PX18fDDD5ffp8EcGHPu3DlxX1VKMTo6yqOPPgrIltq6u7vLZ9fbOL8uRD80NMTc3Bxnz54VXU9nZydNTU1Oiv4zn/kMd999Ny984QsTfxd1Amjao7XDdTS4EhX9JY3gFjsb1WwIC0jdvwkbYWGj6G2I/uLFi0xMTFiFzWZnZ5mZmQGqp+gNiZj2k3R+4/AcO3YMSE92Ay9LfXBwkCeffBJATNoHDhzg5MmT4vAhuBM9wBNPPAHIrslsnbQh7e0oenOPpO1tQq8uuSFSEgmedy+d3IM2NklbLqRtbKSHJxlcddVVfOMb3wBkcwN49/bYsWMUi8XUpDKDsbExq/FaU1PDwMAAZ8+etUqs279/f3kukdbtuuuuA7xIkmTeUkqxb98+Tp8+bTVewVuSeN3rXide9gkf2y1ZnoONe5nL5cRzcTWQEb0Drr766jLp2Kjm4HqQ2QaXhiDR24TuwQs3mTW2NISVn2RAt7a20t3dXZ44JANtYGCAXC5XJjjJZGMcHtPm0ol6eHiY73znO4B8shkdHeXkyZNWqnRwcJDp6WmmpqasQvdAuX5SRQ92RO+i6E05jz/+OCBXZCZr2tb5NeF+adsFcxVcSFu61BZU9NI92r29vczOzpaPN5a2w1VXXcXJkycBeV/t7+8vO7LSezQ6OlpOnpXajIyMcObMGStH1oTVbcq5/vrry6+l82OQ6KtBpC7P9AjCEL15LPNuISN6B1x11VXldaHV1VXxYA5u65B2ZKMWbUL3ZqKG9KzScH3M5C5VwGNjY+VDKyQDraamhqGhoTLRS52XgYEB60ltaGiovMRiMxFOTEwwPj5uFboHeOaZZ6ydvm9961uArL1NOTYh9ZaWFpqbm8vqXFJOQ0MD3d3dZSfENplKmtENm4leStpBordxDmwOcAmXY5OHA15fADtFbyBV9P39/eWMbhtH1sCo1TQMDw9z6tQpVlZWnIheWk5QCAXnsCQYop+dnRWPVxtEKXobojfz726SPGRE74SrrrqKUqnEY489Bsi99mDnTcv2DNrYrrcHnQipojfh2scff5zGxkbxGlTwOqRnGOzbt6/sUNgqP5BPhOaaQD4RmsM0nnjiCStFD55qlk6EAwMD1NfXWzkv5r4aJ8kmycmUI22HYDREOoGaXSXSjG5jMzk5yezsbNVJ22ZHAHj9+eLFi1YkYu6RcTCrSfTBcW7jyBoYtZqGkZERK+cSNl9PsMwkBPMmRkZGRDb79+/n/PnzTE5OVkXR19fXlw/yAbtzU2Aj2c9EeHYLGdE7wHTiRx55BJCTlVKK3/md3+EXfuEXxIPswIED5bVz6QRgdgbA5ryAJBhSPHHihNWAsTl8wmBkZKSchGZDIgYuRO8yEdoSPcj7Qi6XK5dlnpKVhu7ubmpra8tEL227/v7+8kQjbYfh4eFyEpqtorchejMOjh07JiZFs95uQ8AmMmZTt97eXorFIidPnhSXY/qcIXppWc95znPKr6XRvmBflTrZLop+ZGSEQqEAyMf485///PJrmyS5D3/4wwwPD/Pyl79c9Pt9+/aVH/dcrTVwl0O+DJ73vOcB8I53vKMqdZMifXbJsAWG3EzY1SYJ5N3vfrdVWUHFLFXnQWVktpGkobu7m/r6elZXV61CYNdcc035tTRBxex/Bfk1bZfopUsYweMxpc5YkOil1wPepPvkk0+Kr8fkKphwrY2iN5BO1EGysXEo1tfXWV9fd6qbef53Gvr6+lhdXeXkyZPi/j00NMTKygonTpwQE5whz2eeeWZTKDqtHLBX9DfccEP5tbSvBueGYL+VliOdt4LqWlq35uZmPvnJT24a6xK8853v5J3vfKf498G/Lx1Htggf222j6IeHh3n66ac3RTh2AxnRO2BwcJD6+noefPBBwG5yt4UL0QPce++93HPPPZvILglKKYaGhjh+/LiVZ3z48GHxbw1cJo6gjUtkQzrhBElbuk5o9jRrra3ukbm3UvIFj0hOnz5NPp+32jppYKPoDaTEGCRtqcJ0IXpTt9nZWesw9+OPP76pXyTBXPeZM2c2EWQSenp6qK2ttVb0bW1tfPCDHyxn60sQdHKkbVdXV8cnP/nJ8uOIJQj2BZv+/YY3vEH8W1cEx7WtUyFFf39/OXprm4wHm8XQbiEjegfkcjnGxsZ44IEHgL1J9Lfddhu33XabVVnDw8McP37cqpybbrqJW2+9lZ/8yZ8U2wQHpJTog5Oz1CaYxSvNOQgmzUiJPp/PU19fz8rKihPRS68nWKe2tjbxRG1slFLiMGrQsZKunQcJwSZfw0DaDsGJ0ybnAKBUKllFKAykNrlcjqGhoXIGvc0hKe95z3vEvwXvvr7mNa/hlltuEfcFsCdgF8d8pxCMZEijLrYIh+5tFP1eQUb0jrjxxhvLa6XVJPrgRFbt8M/Bgwf5yle+Ig4DgjexffnLX7YqJzggpd5xkLSlk1prayt33nmnWO0Y/NAP/RCf+9zneNGLXiS2KZVKgDzcDxuKTOpQwAZh2Ty86dprrwVAay1uO5dITbB/SusXvHapOg/mhVQzcS1IcDbLWcPDw5w8eZLOzk5R7sV2cM8991T178PmdpAmye0Umpqays/cCPaLSqKvr4+ZmRlWV1dZWVmxWqrdK8iS8RzxXd/1XeXX1fRylVK85jWvIZ/PV60jG5gDK6TJQK4wiTo2BNzV1cXnP/957r33Xquyjhw5wqte9Sorm0984hM89dRTVqR98803A1g5B7fddhsf/ehH+Y3f+A2xjcnitQkfGtJ+2cteZmVzyy238PGPf1xsE+w30l0ludzGFJR2HKlBsN+4LMlIowAdHR3lx+bajAnz22oKgJ1EfX09+/bto6mpyWqZaadw//33c/ToUXHkyRbBY3AzRX+FwUzsYJdV6oLPfvazrK2tWYXnXPCWt7wFgDe+8Y1VLaeuro6HHnrISpUC3H777VWq0Wa0t7dbZ/B+9rOf5Utf+pJ4KxF4Ttzb3/52q3JuuukmQJ5kCZ6it43U1NfXl5empMjlcrzwhS/kgQcesCrrzW9+M5/4xCfE6+BBBLPVkxAco9IQr1nqWFtbs1KyJuqy18Lc28Fjjz1GsVjc7WpEwqavucDlYVd7DRnRO+JFL3oRN910Ey996UurXlZtba14jXk76Orq4ud+7ueqXg5sjohcDhgYGOD1r3991cu59dZbuffee7nxxhut7L7v+76vSjXajPvvv798HrgUf/zHf8yHPvQhqzD3F77wBe655x5xFAA8sl9eXhZHG8BzqL70pS9Z2Zgow24fklJJXIrh6kohSPSZor/C0NzcXD6bOkOGnYRtkuVOorGx0TrClc/nrYnkFa94Ba94hd3DLO+++24+9KEPbYrGpeHDH/4w9957Lz/wAz8gtnnxi18MwC233GJVvwx7EyZCY44BrnYEtxrIiD5DhgxXBG6//Xbr5Z8bbrjBeknhlltu4d577+XWW2+1ssuwNzE0NERNTU35GRjVOGq32siIPkOGDBkqjL0cdclgh3w+z759+zh27JjVY8n3ErKs+wwZMmTIkCEBBw4cKD/bJCP6DBkyZMiQ4TLD6Ogojz76KJARfYYMGTJkyHDZIbiFLyP6DBkyZMiQ4TJDkOir9ZS8aiIj+gwZMmTIkCEBwYOwpA8K20vIiD5DhgwZMmRIgDkeHKr3lLxqIiP6DBkyZMiQIQEDAwOMjo7S1NRUtefeVxPZPvoMGTJkyJAhBV/72teoqamp+jNHqoFdUfRKqS6l1L1Kqaf9/7e4SEqp5yulvqqUekwp9YhS6nW7UdcMGTJkyJChv7//kn1Q0W6F7t8L3Ke1Pgjc578PYwn4ca31DcArgd9TSu29ZyRmyJAhQ4YMexi7RfSvBf7cf/3nwA+Gf6C1fkpr/bT/+llgArB7rmmGDBkyZMhwhWO3iL5fa33Of30e6E/6sVLqFqAOeCbm+7cqpR5SSj104cKFytY0Q4YMGTJkuIShtNbV+cNK/TMwEPHV+4A/11p3BH47rbWOTGVUSg0CXwLepLX+mqDcC8BJp0rHoweYrPDf3C1k17I3kV3L3sXldD3ZtexNVOJaDmitI6PeVcu611rHPr5JKTWulBrUWp/ziXwi5ndtwN8D75OQvF9uxcP7SqmHtNbyh1jvYWTXsjeRXcvexeV0Pdm17E1U+1p2K3R/D/Am//WbgM+Hf6CUqgM+B/yF1vqvd7BuGTJkyJAhw2WD3SL63wJeppR6GrjNf49S6mal1J/4v/lR4P9n783DJDvKM99fZNaetVdl7dVd3VK3FhCShdAFm20QWDKPBZ4Z24B1scCY1dwL2GPAaOzBzCMbPBjPtc1lMWZsg7DAeGxLFsIIIUDytYQWa19b6lWt7uru2tesyoz7R2ZknTx1li+iMququ8/7PP10VtaJijhxTnzv937xRcSrgXcopR4s/btka5qbIEGCBAkSnJ7Ykg1ztNangCsCvr8P+PXS568DX9/kpoXhy1vdgCoiuZftieReti/OpPtJ7mV7oqb3UrNkvAQJEiRIkCDB1iPZ6z5BggQJEiQ4g5EQfYIECRIkSHAGIyH6EpRSVymlnlJK7VNKrduSVynVqJT6Zun39yilxja/lTIopUaVUncopR4vnRXwoYBrXquUmvYkOv7eVrRVAqXUAaXUI6V23hfwe6WU+tPSs3lYKXXpVrQzDkqp8zz9/aBSakYp9WHfNdv2uSilvqqUGldKPer5LvbcitJ115aueUYpdW3QNZuJkHv5H0qpJ0vv0D+Ebbkd9z5uBULu55NKqec979IbQ8pG2r7NRsi9fNNzHweUUg+GlN1WzybMFm/6uNFan/X/gDTFXfd2U9yB7yHgQt81HwC+WPr8VuCbW93uiPsZBC4tfW4Dng64n9cC/7zVbRXezwGgN+L3bwRuBRTwcuCerW6z4J7SFHeF3Hm6PBeKq2AuBR71fPdHwMdLnz8OfCagXDfwXOn/rtLnrm14Lz8L1JU+fyboXkq/i3wft9H9fBL4LzHlYm3fdrgX3+//GPi90+HZhNnizR43iaIv4nJgn9b6Oa11DriR4n78Xnj35/82cIVS2/O8Qq31C1rrB0qfZ4EngOGtbVVN8WaK+y1oXdxYqbO0EdN2xhXAs1rrau/iWDNorX8MTPi+jj23ArgSuE1rPaG1ngRuo3hQ1ZYh6F601t/TWq+WfrwbGNn0hjki5NlIILF9m4qoeynZ3F8G/nZTG+WICFu8qeMmIfoihoHDnp+PsJ4Yy9eUjME0sO3PLCxNMfwUcE/Ar1+hlHpIKXWrUupFm9owO2jge0qp+5VS7wn4veT5bTe8lXBjtWXPpTR1cMTz82NKqddGFJGcW3E6Pp9foxglCkLc+7id8MHSVMRXQ8LDp9uzeRVwXJcOPAvAtn02Plu8qeMmIfozGEqpVuDvgQ9rrWd8v36AYtj4YuDPgH/c7PZZ4JVa60uBnwN+Qyn16q1u0Eagirs+vgn4u4Bfb/i5lOYpF5VSs0qpKaXU/6eUep9Synq8a61fpLX+ofBaTdHQWkMppZVS57qUrTaUUtcBq8ANIZecLu/jF4BzgEuAFyiGvE93vI1oNb8tn02ULd7IuJEiIfoingdGPT+PlL4LvEYpVQd0AKc2pXUOUErVU3yxbtBa/2//77XWM1rrudLn7wD1SqneTW6mCFrr50v/j1PcFvly3yWS57ed8HPAA1rr4/5fVPG5XK21bgN2Utx58mPAX26gzWE4bqZJVPi5FTV9PqXxWK2/9Q7g54FrSgZ4HQTv47aA1vq41jqvtS4Af0FwO0+bsVN6zv8J+GbYNdvx2YTY4k0dNwnRF3EvsEcptauktt5KcT9+L7z78/8i8IMwQ7DVKM1j/SXwhNb6cyHXDJgcA1U8BjjFNnRclFIZpVSb+UwxYepR32U3Ab+qing5MO0Ji21HhKqSaj8XrfW01vom4C3AtUqpF6viCpLPKqUOqeIBU19USjWHtOeAUur1pc+fBP4cGC5FCx6jGIY04+KDpetOKKX2K6X+79L3/wL8vFLqJ0qpaeBdwOtKYw2l1I9L1z2klJpTSr2l9P27S5ngE0qpm5RSQ552aaXUb6jiNtphYVwrKKWuAj4KvElrvRByjeR93Bbw5an8R4LbKbF92wWvB57UWh8J+uV2fDYRtjj2vBeK4+ZnlVJdpWmXny19Z4+tzkrcLv8oZm4/TTED9brSd5+iOOgBmiiGWvcBPwF2b3WbI+7llRRDQQ8DD5b+vRF4H/C+0jUfBB6jmGV7N/DTW93ukHvZXWrjQ6X2mmfjvRcFfL707B4BLtvqdkfcT4YicXd4vqvqc6GYefz6gO8PAe8H/oSioemmmAl8M/CHpWteCxwJ+lulvtUUw9pHKJ4seR9wO0WynQH+kGL29ptLP19ZKvv7FOcb9wH/hWJS0oc99WjgXM/Pr6N4bOelQCPFaYwf+66/rXQPzQ599LcUw9krpXt5V6lthz1jxqyyGQK+E/U+bvW/kPv5WumZPVx63oP++yn9vM72bbd7KX3/V2aceK7d1s+GcFvc4xk33we6S9dfBnzFU/7XSu/lPuCdru1ItsBNkOAMg1LqAPDrWuvv+76/myKpfwJ4idb62dL3rwC+obXeVUq8+7rWesT/t0qK/pW6dAS1UupC4H6tdbNS6v8A/k5rvcNT3+8Ae7XW7wxo44eB12it/2PpZw3s0VrvK/38l8AprfVHSz+3ApOlaw6Urr9Ca/2DKnRZggRnNLbkUJsECRJsCYYpjvkW4H61tjpUUVxPLcExz+cFoKk0d7oTGFJKTXl+nwbuBFBK7QU+R1GxtJTacX9EPUMUExMB0FrPKaVOle7hQOnrwwHlEiRI4EMyR58gwVkApdTLKJLkPwKLwIu01p2lfx1a69YNVnEY2O/5m51a6zattdmN7QvAkxQVeTvFqELUPhRHKToPpv0ZiuFObzJSEo5MkECAhOgTJDiDoZRqV0r9PMWNUL6utX6IYgb2nyil+krXDCulrtxgVT8BZpVSH1NKNSul0qXEv5eVft9Gcc5+Til1PsVcAS+OU5xjNfhb4J1KqUuUUo3AH1Dc8fDABtuZIMFZh4ToEyQnYWlaAAAgAElEQVQ4M3GzUmqWotK+jmLY3MyVf4xics/dSqkZislA522kMq11nuKytEuA/RQT6b5CcRkqFBPwfgWYpeho+JdIfRL469K6/18u5Rf8LsVlSS9QXA/+1o20MUGCsxVJMl6CBAkSJEhwBiNR9AkSJEiQIMEZjIToEyRIkCBBgjMYCdEnSJAgQYIEZzASok+QIEGCBAnOYJxxG+b09vbqsbGxrW5GggQJEiRIsGm4//77T2qts0G/O+OIfmxsjPvuu2+rm5EgQYIECRJsGpRSB8N+l4TuEyRIkCBBgjMYCdEnSJAgQYIEZzASok+QIEGCBAnOYCREnyBBggQJElgin89z0UUX8ba3vW2rmxKLhOgTJEiQIEECSzzwwAM8+uij3HjjjYyPj291cyKREH2CBAkSJEhgiSeeeKL8+d57793ClsQjIfoECRIkSJDAEocOHSp/fuyxx7awJfE449bRJ0iQIEGCBLXG4cOHyWazaK157rnntro5kUiIPkGCBAkSJLDE5OQk3d3dtLS0cOTIka1uTiSS0H2CBAnOTuy/Af5xDL6RKv6//4atblGC0wjT09N0dHQwMjLC4cOHt7o5kUiIvoq49957ecUrXsG+ffu2uikJElQf25wY7733XvL5vOzi/TfAT97Dw08eJLeqYeEg/OQ9Nbunm/7iN/m7385u275LYI/p6Wk6OzsZHR1NiP5swqc//Wnuvvtubrzxxq1uypZiZWWFpaWlrW7GaYn3v//9fOhDH5IX2H8Di9/cwfRXVG0JpESMLBwEakuMWmseeOABtNbiMvfddx+XX345H/3oR2UFHrqOQ8cXuPh34B1fLH2XX4CHrostKnYmStDPfZ03v+dP+OXPnmQxV3unIsHmYGpqqqzoJycnmZ+f3+omhSIh+iri2LFjADz44IO1q2SbqyqAX/3VX6Wvr4+pqSlxmXw+z8rKSg1bVcJm9Z9DPXNzc3zxi1/kT//0T5mdnZXV8ZP3cMEHD3PpdVgRSC6XY2JiIr4Og4eu418fX+DXvgzL5jEJidEWN3/lt3jpS1/Kn10r77sf//jHAHzve9+TVbJwiO8/Wvz4zbsrv4/C5OQkfX19/NEf/ZGsHuDYDz9e/vzk0dKHGvWdC771rW9xxRVX2L0PDpienuav/uqvrBw4Vzz55JM1r8eE7kdHRwG29Tx9QvRVxIEDBwDYv39/bSrYRFVVrs+SrLTW3HjjjczOznL33XfHXm9w3W/8Ak1NDRz9fA2V6f4bOPH9d/M3/3KwaASE/Tc+Ps7LX/5yeaRm/w0c/e6vM/bug3z6Jnk93sxd0fTPQ9cxNbPAwZPw3Dgcn0ZMINdccw09PT3yyMvCId73VfhfP4K/u6fy+yjce++9nHvuudxyyy2yevbfwI/+6c8AuOMJxH1nxp5YVbXsYP+J4sdUCgqFte+jcNtttzExMcHHPvYxWT3A/kPPlz8/e9zzi5i+2yx89rOf5Qc/+IH8GTni7W9/O+985zu54447alrPww8/zAUXXMB/+2//rab1GKIfGhoC4OjRozEltg4J0VcRxiM2RqfqeOg6yC8wtwR/cyfkC1gpgy996Uvcc8898RdC2al48PGD7DsmJ6tTp06VPz/66KPiuj73lX+mUIA7n0Rc11133cVv/dZvyT33h67j5/5wkWu/CA+ZAx0F/XfLLbdwzz338Pu///vien78+BIHT8L1/ySvxzvP9+yzz8bXs3CIAyfWftx3bO37OHz7298G4Ec/+lF8PQAtOzg+U/x473OV30fhlltu4dlnn+WGG4SO20PXcWB8FfDcj6DvXnjhBQAOHjwoC61ffD2HJ9IArOZLTlK6BS6+PrKY1wGTvncnlteOCB+f8fwipu/m5+flz2cDMLu6PfLIIzWtx7zTP/zhD2taj4nqmHe8FlhZWWFxcZGOjg4GBweBtYjudkRC9FXC0tISS0tLNDU1MTExQS6XE5XL5/McP348/kIoG/DP3AzXfhFu+NfK76Pw7LPP8r73vY9XvepVsroeuo6FhQV+6jrY81umsXKD6/8cBf3gJ4pOC/CoiX4J6rryyiv53Oc+x1133SWqh4VDPFFyuu98qvL7KDz++OMAnDx5UlzPIyXOnlvyqMWYeryhP5E6aNnBoTW/isMTa99HwTul8vTTT8fXA8yd+7ucKJFUOfwsIEbj7D311FOR15WxcIgXSs3z3ltc35l3rVAoyELQu67haOGC8o/juUG4/Muw65rIYt6oi3Tb0xMdb1orY4he0Hdvf/vbee1rX1uxA1stYPrLuwFMtaG15vnni5GNZ555pmb1wJrQquVUxPT0NAAdHR0MDAwACdGfFZicnATgvPPOA+Sk8NnPfpaBgQGZwS0ZcEMi9+yr/D4KZovGlZUVmRJZOLRGusDJ2bXvo+BC9DOnDlEoNenoZGUbIpu4sADIt5/MN46yUhSLPOe10TH9ZwzHyZMnWVxcjK+oZUfFfZSNe0w93nfmxIkTEVeWcPH1nJhrKP94+BQiAvFGnKQrRI7U/Uz589FJoGWniBiNcReHNVt2lIl+ZhEWlte+j4K376SO88RiI+3t7QCcuOhvYu8FKsldSown9DkAtDSq4rsg7Duj5m+77TZRPYD1dNvKyko5H6SWRLWwsFAmx1oTvXnnjh8/ztzcXE3q8BJ9Z2cnjY2NYnu3FUiIvkow3uP5558PyL39r33tawDcfPPN8RdffD2kW8ok8sRRRIYdKgeXyBC27KiYT3zq6Nr3UTB/u6+vT2w4ji0PrZWfrmxDGIxjBcXEGwlOjH6UlVJU18zPSvrP2rhffD3HpteGlpSAJycnaWlpIZvNyoh+1zVM9vzn8o9HZtpEBOJ9LlJSNES6Z88eji50wy8cEBGj+fvj4+PikPqpOehoKbVVGFKfmZlhz5495bokmJiYYO/evVZlTp06RUtLsXFSZ35ycpLGxkbGzrmA8Y7/LO671dWiVyqNurD/Bv75C++i65qDHDghm27zjqNaEr23r2o9l+39+4b0qw0v0SulGBgYSBT92QC/opcaUKMQRWS16xq4/Ms8P1WcWzx4qk5k2KGSoEQ5BBdfz4FT9eUfnx1HbHCh2A9iou95JwDplDy06Q1zS7NdT7a8pvzZRpWOj4/T1dUFCJ/rrms4tjJKf2dxeL2wmBXVMzk5SWdnJ319fTKiB6ZSu0mn01xwwQUcbni96F0wTmk2mxUTnDHUL3nJS5iYmBAl8WmtOXbsGE1NTRQKBdE96bFfYW5Jcd5wMVJxbKlf1Hezs7Occ05ROdsQvRmv0v4+efJk2ZmXlpmbm6OtrY2+vj6xXZieni6PJbECfug6PvntZaYW4FsmDzZmCszYre7ubjuisowcmPfnoosu4vjx49ZLFG1w8uRJhoeHgdplwnuJHmBwcDBR9GcD/EQvMTZa6/KLKEq+Ago738axqWKc++h0HXrsV0TlvEZJSlYnWq5YK7PQKTa4UFR+UsMx2XQZABeM1ItDm2aeuaGhQWw8TaLg0NAQ4/mdYmU1Pj7OhRdeCMiN+6nZAue95JXFz3s+I6pncnKSrq4uKwI2zsGOHTvEm3aYfrjgggusif7iiy8GZKpscXGRxcVFLrroIkA2lTM/P4/Wmj2X/xIAx/b+v7F9l8/nmZub49xzzwVkYy+fzzM9Pc3u3UVHSfxcT50qE71U0c/NzdHa2kp/f798Xt/THrECXjjEYik16MkXKr8Pg3H6LrzwQqanp2WrMPbfwOyP3s1d/y5f/eMleqnT54rJyUle/OIXA7UjejNtmMlkABJFf7bAJXR/6tSpctKelKxmZ2cpFAoMDw+ztLRU9izjMD4+Xg5tio3aah87duygubmZY72/JiKr2dlZ0uk0u3btYnJyUmQ4DGmf97I3cXyuCf3m/bF1mfveu3eveIB5CU7aB1prpqamyiFeqXGfnZ1l165dFfXGYWpqqkz00vYZorchEdOe8847z0r9AmUDKiEf4/QZ51fynLyOIsicAzMPu3PnTtLptOiejFru6uqit7dX3A8zMzOMjo5SX19vpehbW1utFL3p79HRUXlSa/NoMfKGbxlfxBSYl+hBaIceuo6P/PUir/oU3G9WEsdEDkw9L3rRiwB5/o5t5KBQKDA9PV2uR0z0lvWYSGxzczNQJPpE0Z8FMIp+bGyMhoYGkeEwpNHZ2SkmK0OKZmBKvf0TJ06Uy0jJ6uTJk/T29jIwMCA2UDMzM7S1tdHf3w/IHB4vaS8tLYkSaIyh3rt3L+Pj4xTKqe3hMMbmvPPOY2FhQbTmenFxkUKhUCZtUfhZa2ZnZxkeHqaurk5M9CbEa0P08/Pz1mWmpqZob29ncHCQkydPisKoc3NzKKXKqlny3pnnaJwkiSE0z9UobUkZ4xx0dHSQzWZF76p59plMRjxVksvlWFlZobW1ld7eXmtF39vby/T0dHnuPQpeYvQKgihM776uvJnREZNwHjMFZuzWBRcUVyCIyGrhED8qLQT4/qOV34fB5V1g/w1M3fFuPvKlg0zOyyIHRggNDQ3R09MjI/rSUmI9L49QGEVviH5wcFD8nLYCCdFXCWbAdHR00NfXJyI47yCbmJhgeXk5psQa0VsNTIqEu3PnTlpaWqzClD09PfT394sdkdnZWdra2ujt7S3/jTiYezIkIjHUXudgdXVVtJTGGBszlyvpB1Omp6eH9vZ2UZmlpSXy+TxtbW309PSIiX5+fp5MJkM2m2ViYkJECPPz8+UEvsXFRZHzYojHHLEpaZ+3DMieqyFgm+fqJe2enh4RmRrnoL29nWw2KyrjJXqpk+Qt40L0PT09gGzZl19pS8bfiZb/AEB3a0o8BeaPRIpsQ8sO5kqm6rEjld+HwYwjm0gND13HF7+3yP/8Llz/j6XvYiIHxpZ0dnYyMjIiI/qHruN/371A57s9Sccx9RhFbxIzzRI78VLpTUZC9FXC7Owsra2tpNNpsREwRG8Gs8Q5cFH0y8vLzMzMkM1mrZTf7OxseZ2oLdEboyYhhOnpadra2sobT0jaZ4jeJvnRGBujziX9bYjHKDJJ20wZF6I3pA0yQlhYWCirUpDdk3EobMrMzc2RyWTo7u4G7Ig+m82SyWREY8Lbd9Jx5CV6aX8b0jYEbFvGNuriJXpJXX7bICFG054X/dTPMLcEi1c+ETsFZt4xm2m93AW/X14dc9A8npjIgRl7xumTRg7MEt9njlV+Hwbz/rS3t8uJfuEQf3RzcTnn39xV+X0Y/KH77b5pTkL0VcLi4mLZu5MaATPIjDqXvCR+RS8hemMs+/r6rAyUUSI2oXsXojfhflvnoK6ujrGxMUDWd/Pz8zQ0NJS3rLRR9CY8bktWLoreREOkytTrHEiVqVedS52D1tZWGhoaaG1tFTkhLqS92URvo879ZWzGUSaTsXq/XULd5h5sEkenp6fLY1xa5ljzf0B7970QRA7m5uZobGwkk8nQ0dEhjhwYR+KpFyq/j6oHis7YyMiIbHldy47iMk7ggf2V34fBH7rf7pvmJERfJSwsLJQfutRw+Elb8pKYF3lgYIDm5mbRgDGGPJvNWhsoky188uRJUSjZheiNKrUl+o6OjnIugJS0bZWsV9FLnSQX4oG1frAhelPGhuj9xCOd9mhtbQUQ39NGiL69vZ3e3t6a1eMl7Z6eHiYmJmLzPLwkks1mrXIvbBX9/Pw8Sil2794NyGyDee9s9hMw708mk6G5uVnUd+Z9GRsb4+hsiyh51vv+iJMSL76eQ6cUUNz1UWtiIwfe5zo8PMyJEydip0SXz/9keRfGfaZZMfUsLi6ilKKxsRFYU/TbNSFvS4leKXWVUuoppdQ+pdTHA37/aqXUA0qpVaXUL25FG6VYWFioUPSSAeMPZ0kGs/EkbTZWMWFA24xubxIRyAjBEL1NiNeoUhviMURvQ4r+eWbbMHwtFX2hUHAieu+8PsgVvYvCNIa6u7vbSpVuhaKP2/3RT/SFQiH2tEW/op+YmBAnMtoS/dzcnHWkxvSdTQ6KGXsgj0Qae/KiF72IhYUF0UmL3vdHukJEj/0K47N1QHGHxFk1KoocQNEZk4bTxzNXoDV0taY4dAoKTTti61lcXKS5uRmlio6IEQ+JovdBKZUGPg/8HHAh8Dal1IW+yw4B7wC+sbmts4eX6E12bVwGpvHazTGHtUoicgk/53I5crmcEzG2tbXR0NBAW1ublaJvb28nlUqJw/0dHR10dXWhlLIiRaNepHPTQEWmdRyJBBF9XBlvco+tom9paXGao7clHrNm2CjgOPjzG1ycJEl/+4nerJGPgp+0Ib4f/GW01rH9kM/nWVhYcFL0ZqpEGuo276qJAtgoekAc7fMvlZOuwPAqemnblpZXyks6j132fVHkAIrPyEzRxalsc8+XveIKcqtw/BV3x9ZjiN6goaGB3t7eRNEH4HJgn9b6Oa11DrgReLP3Aq31Aa31w0D82qkthl/Rg8xwGNLJZDKiQeZV9NJlQX5VurCwUP47UW0DKhS91FCb/cNt5ktbWlpIpVJitTg9PU17ezt1dXV0dXVZKXqllHhTGr/CXFpais1s95NVLpeLLePdgMMQgq3z0tTUZDVH39TUREtLixXxQG1D9zMzMyilymS6urpaJvIw+J0xsCNtaX+7jAnzXFtbW8lkMjQ0NIj72xCw7Tg3eStSMrWNRHoVPdSO6E0/lYlemIcDlYo+rn2mLWZjJ6kd9hI9bO9Nc7aS6IcB71ZeR0rfWUMp9R6l1H1KqftqueNSFLzJeMYIxLXFO5htlvik02kaGhqcyEqqzv3zkRBv1Mz68ba2NkBOCF5VIS0zMzNTdihs5mVtjU0QicTV5Sd6sCOepqYmWltbY+tZWVlhdXWVlpaWsvNiE7oHeX+7hO5nZ2dpamqirq6O3t5eZmZmYqNcZvWKUkrc30tLSyilqK+vd+pvqXPgVYvStnnfH6WUeMmgN4JiM85bW1tpa2uzcvpsFb3LEl8/0Uv2bzD9ZLPJzkYUvbkfSR947b3Bdt4054xIxtNaf1lrfZnW+jJDSpsNr4cnJUb/YLYJ1doY9o0SvdSo5XI5VldXrUnEO08oLeN3rFyMp03fbZTopWrR5p68ZAVy52WjRN/T08Pk5GRs8prX6ZOSaZDDLCH6pqamMpFKynj7eyPOgQ3Rg92YMGVspuja2trKTpKNPTH12OQWmSkC6dJWL9FrrWPrcklW9k9tptPpWEVvIkY2uQ3+0D0Ut9au9YE9rthKon8eGPX8PFL67rSEf44eZMbG1pv2J89INkmZnZ2tCIeCHdEbQxhXxmx3awaAjaK3JXpj3MGO6F2MZ319PY2NjdZE7xpKBtk9eadxQHZP3qQ/cCd6s9VoXBk/0UtJ26bM8vJyOfvZpr+bmppIp9M1Dd37HTib/nYJ3du+3/6o4uzsbGyW+vz8PM3NzXR3d4t3AfUn40H81IIZRzt37qShoUGs6BsbG6mvryeVStHf3x9bztRjHBeJLQki+tHRUY4ePVrTA3tcsZVEfy+wRym1SynVALwVuGkL27MhBBF9LUL3XiMtVefecKiLom9sLJ7bLTHSQNlQ26gX20QvF6IP6m9JYp3XeEK8IVhcXCyTiJR4/IdkuCh6yTvkr0fyjFZXV1leXi6Xka6o8JKVDWn7iT6uHu+7YKPOTdtMroekjFKK5uZmsXNgSNNlTPhJW7L8z+tY2Sp6GxGQyWRQSomXyvkVPciJ3ux4aOu4QFFlS4g+lUoxPDyMUkpsh/2h+5GREfL5/Lacp98yotdarwIfBP4FeAL4ltb6MaXUp5RSbwJQSr1MKXUE+CXgS0qpx7aqvXHwq1KwU/S2oXtTBmREbwyAC9GDzHAEEf3U1FTs+vtqKHoJafuNjSSxzh91AZkq9StMW9J2VfRxxtOrSqFI2nGOlb+MdBnk0tJSxd4SUJu+8yr6jo4OUqmU1diTzp2bJW+G7CW7/RmiN+1zUfTZbJZ8Ph+7/M8/VeKi6EH2rrrkurgSvU0yp7ceKK5vjwunm36zSewNU/SA+BTJzcSWztFrrb+jtd6rtT5Ha3196bvf01rfVPp8r9Z6RGud0Vr3aK1ftJXtjYJ3btG8MLaKXpoN76LojQHo6OgQnbwVRPRxZYLUC6xl6QZhZWWFlZWVCoW5sLAQe+qdl+iz2Sy5XC7yMByt9brQPcimI8yA7ujoEB1p6m2bdPlftebo46Zy/GUkm8V4E5xMGYhXzV4Ctulv03fG+NqE+1OplIhM/cpPsjlPUBnXKJdknb+fGKWRO3ATDi6RyP7+/lhFr7WuqKfWRG+r6L2REGnkIIjoR0ZGgIToz1isrq6Sy+UqHrxkoAWpRUno1WXAGANgEnWkRG8TcQgyahBNCH5VKgkLFwoFcrmc1VxuLpcjn89bO0lBJGJDPOl0mu7ubidFHzdfGqTo4+4piOjj5tv9uRfS0L23H0wZG3UuTSrzlgGZavaHXnt6eqycPrBzfr2KfnV1NXaTmSCHPm6c+0P3cXt55PN5lpaW1r0/ksiGjaI3fWD6rrOzk7q6ulgHwZtbZBO69yv6EydOsLKyElmPbSQkaHmdUfTio3E3EQnRVwH+k4xArshcwmYbUfSmnC3R26gXr1EDGdHbqEVjvGyI3v+MpH3nJxEp8Zi2Scv4SVsyPx1WJqoufxlJfweRVVwZqCT6+vp6Ojs7rZwkkL933jISZ8z/jCQJb0HvggvRQ7wj65+jB7txLnl/zJiwFRtBij4qQuEXAKlUSuQg+JdauobuITpj39tv3d3dsVMkEKzou7q6aG5uThT9mQq/8QQZmbqQtleJmES5WhB9EDFKs+5tFH1QVjJEz//665EQnN8JkaokP4lIIxsuzgG43dNGykiekb9MZ2cnSqnYOfrNcpKCythMK4Ds/faXkZCVS3/7Cdg1dB9Xxj/2uru7SaVSIhHgVfS5XC5yUyN/H5hyEqL3Oi6Tk5NW+T6AaC29t56urq7IqUYD/zsHlHc5TRT9GYogoo/z9rXWFV67izctXUvvQvRmcDY0NJTbt7i4GJlDUI3QvQvxuBCcS+je1FUrVQpYJaKF9UO11bm/TDqdprOz00rRm/a5OEmSemxD90GkferUqUgi8ddj5n+j8hv8fecSdTFloohRa83i4qJV4qg/miadmvIreoheS18NopfuNup/5yS743nr6ezsFCn6XC5X8S4YjIyMJIr+TEVQ6N6EAsNCWsvLyxQKBevQvd9jlapzb4KKVL2YTUhAZjjCkvEkit4mdO9C9P62mS1gpf1gUCuiN+3zOlYQ7Yi4kIiLM+avx5SzJdNaOklBofu4cLJf0UN8P3jrGR4eZmVlpeqOlT8nQrLf/erqKoVCwcqRdREoYJ9B7x97ppxtzgHY7cMAbop+eno6di388vJyeax6YXOk92YiIfoqwBC9/0VeXV0N9Q79BNfR0UFdXZ1V6B7k6twffp6ZmYlM9AozhDYkYrKmJWFK7yY7YEf0JhveJnQvjYaEKcw4FRdEcFHEY8oYx8plCqOzszN2adlGiMdPppLldS4OT5BDYdPfPT09LC8vR0afghQ9xBOWX9FDtFp0ibq4KGAX59d/pjrYTzluRNFLkvE2SvR9fX2kUikx0Xd2dgJEJqfm83kKhUKgorc5HXQzkRB9FRCkeOIMh99rl2TDa63XZf5K1k4HET3Ek7bfSEO0QvAPaLM+2caoNTU1xa5PDqonru+CVIWLk9Tb2xu7pjmoTNzyP3+Zrq4uIJro/e+dJPTqL2OcA5t6QLbfvUuuQlh/x60KCHpX45R2kCMb9w7ZEn1Qf8cttwwixrh31S82enp6UEqJCNi/kiCqbf5lqhIHKeh++vv7WVhYiFwK6s05kE5t+t+FdDpNX1+fOHRvxl3U+PZH37zIZrPMzc3FLg/ebCREXwVshOhtEr3CQmAS5yCI6OOMmivR24R4w/pOYjj8hrraxtO0z6UfgsrEPVvv/TQ2NpLJZEROkg2ZBmVAd3V1OSl6Seje3w9xeR5h/W3Td5INq1wUfdAcPcgUvSEFs9zStr/j3lV/mbq6OrLZbCTRuzi/S0tLaK3XTTm6KHqI7u+gOXpbRxGi19KvrKyUj+OGNUUflZBnVv2EKXpJOzcbCdFXARshepvM36B6stks8/PzZY/ej5WVFbTW1kRfjdA9xBNCNcKUNmVsM63D+qHWRA/x4fHl5WVSqRR1dXUVddkoeohX5y5z9Pl8ntXVVet+CIoCSMr43zmojaK3TfQyc7mp1JqpjYu6VGtMxB2bGuZQRE2V+Jfd1tXV0dPTYz32JETvPxoZot+DIFEDxecURvT+qMZGFb008rDZSIi+CqiWoo8LP4cNTAh/scIILqqMKeetx2xyYdu+Wip6fz/YJgS5THtIljoFzdGDHVlB/Pa0/nl9U5dNrgK4OWPd3d3Mzs6GbkQS9Fzj+mF1dZV8Pr9hJ0kauvffTyqVspqjN0dFP/98+FlcQQ5c3DMKyvkxEaswAt4I0fv7rlAohCraoMTjuN3xXBW9d616Q0MD7e3tVgmJBlGnyvlzhBJFnyAUYQMGwl/kMOKxDd1LiX6joXvXeXAp0W8kTAnxUxhhqiJu22F/P2ymoo8j+iDnQDpHv1FnLC5ZMMyRhfB+iHIO4hyRIEVv09/mFDsbBw7ijyYNe0Yuofuo3JBqKnqwsydxiXVRRB9XzsY+BtUDRUU/Pj4euHTSX6Yac/Rwmil6pdTDgn+3b1ZjtyuCDFRcSCtMaU9MTISu5XVR52FqLC47O8hASSIO6XS6IpQct7d3GAGPj49HLk3031M2m2Vqaip0y08Xo7a6usrq6uqmhO79IWuQhdTD1GJc39XX15e/kxJPENGHlYtyfm3eVWkUwD8VEdW2fD6/rgzIIkm2RO+i6F0UcFCZwcFBjh07ZjWO4vo7KIGvv7/faaot6n7821ybtrkSvdY60KnwK3pD9BtV9KcV0bqaM64AACAASURBVANp4OqIf28CsrVs4OmAIKKH6NBwlFELM1BRit6mHpOdbTNHb+qyLdPT00MulwvNrg0L3a+srIRmWkcZjji1aEP0QWUaGxtpa2uz6gfJ8r+gnbbi5uiD+ru3t5fV1dXQncpMGW+43yXqEkf0LiQSVCaTydDQ0GBVpq6uLnJDn6jxaqvo4zb0Ccu9kDi/G1XaAwMD5HK5UNKqlnBwUfRNTU20t7eLVyWBPP8kKHQPwWvp/W3LZDKk02lnRS/dNXKzEUf079VaH4z4dwD4wCa0c1sjzHBEKYQo4onzpm0GZtjLLzFqtmXCwpRgp/xc1Itr8iPYGTVTLioK4J8nlOzVHRW6j1JkQVEXiCbToGc0Pz8fuq/C0tLSuqQ/6XP153lERZKCnlFc34WNvagpDJfxqrUO7DuX6ZXe3l6WlpZCp4yi3u+4d9VLjAMDA0D4Pu/Vcij6+/uZmZkJXVIWZoOi+rsaKw8MTNJkENH7Fb1SKnYb3ChFn06n6ejoEG2ju5mII/pXKKVGoi7QWt9VxfaclnAxHC6DLGjAxB0760JWplxQGdtwv0T5+cP9rksTXctU00kK629J2DGIRKJOOgtTmBBN9EGkCOHz7WHOAcQrev88eNRJfi59F1YmKkoR5FBAvAOntQ7su5mZmcikxLBnZOMkubzfLkQvDd1vdFrBlAuLBPgJ2LTNJXQftalPUOJj3Da4UYoe5PvlbybiiH4I+Del1J1KqQ8opc76MH0QNuKxusxh+hWPC/G4hOF7e3tjcwjCFGaUUQtqG7gpehvSdlmxYOqyNWouil6S8Gar6MOmVyCatG3LRL13tkpbouiD+sEldD85ORlI2mHvgskHCCOGqL6zIVOX/IY4ol9eXkYpVZGv0dTURGtrq7WiB7toGkQn0Ib1QdQ+DFEOBQQTfVAkZCOK3pQ/rUL3WuuPADuA/wpcBDyslPquUupapVRbVNmzCWEeXl9fHxMTE4GGo1pzxqbcZil6iCYEF+UXZADALQwfVUYpVRE5aG9vp6GhwZq0o/rOhaxMXWEkEqW0XRS9y/SKv4yZO7dVzS7qPIq0w+pxCd2bfggy8mFl4hL/XJ1ff10NDQ10dnZajfO4I1qD8jVM+1wUfZg6X1paoq6ujnQ6XfF9lMMcpOhdp9qi8gHCFH0U0Tsr+v03cOx/jTL1Fwr+cQz23xBaR7URu7xOF/EjrfX7gRHgT4APA9tv5/4tgtkUwz9gohLEgl5KqadvE3KMIquJiYnQwxvC5ugheqBVg0TiliYuLS2t24TErPOPyoloamqqeEZx0ZA4xypo7nwjij4odA/Rit6W6Kul6OO2N45S2i7q3LaMpG3+e4rKuA6rx8UZk4zzurq6CqcU7JN729vbaWpqiiR6//2Yeqqt6IPqMYo+aG+Aak0reNtoo+ijQvcSRb/uHdp/A/qedzP4a0e45BPAwkH4yXs2jezF6+iVUhcBnwI+DywDv1OrRp1uCBrMEK1Mg17K+vr6SK89inhcVKnW2imkHmUEbBVPUN81NDTQ1dVl5VBIpjBcjVqQY7WyshKY2R6nSsM2PAlLxgO7CEp7e3vkQUJRDkXUuxD0fkvmwV3m28OmjIKc0ihFPzc3F7jcciNEvxlRl6WlyvMsDGwJWCkVuZa+WkQvUfRhRF8oFALfobA5eqgu0W+aon/oOp55vljXwZOwmAPyC/DQdaH1VBNx6+j3KKV+Vyn1GHADMA/8rNb65Vrr/2dTWngaIIzoo7LozUvpf1mqHYaPKgN2pC0ZaP566urq6OjosHIoIH4ePKhMHImEPaNq9l0UwUUdzhKltG0UvSRL3UXRB/W3i2qOWucflVhXKBQCVVZUmbB7ciH6uDl6mzwKU0+1x0RQ+wYGBkK3fw17rrah+0wmQyaTcVL0IBdCrqF7cFP0YatdjPMYR/QV5RcOsd/T7EMn177fDMQp+u8CjcBbtNYv0Vr/gdb6uU1o12mFMKKPIsagPbAhOlkpSmHOzs4GLo9yIauwrSRdwvCmnI2ih3ijFtbftmTlGrqH4L6LIjiwmzuPO8HO1VD729bS0kJTU5O1oo/a0CfK4Qlb5+/Sdy5Ke6sVfV1dHV1dXVYOM0S/q4uLi9TX11vNg7s4v0EK2NTjoughmOg3ouiD7slW0edyudDzQ8LeBYOurq715Vt2cNgzVMqk37Ij8G9UG3HJeOdorf+r1vrRTWnNaQoXoo9SpbbEY+sZg5sqrRXRhxm1uPl2P+IIrlqhe5f+jnoXzGEc/noaG4sn2NmQiKnLxqEAt2fksoQtbkyAXd9tRNGHOVY2RN/R0RG5QUpUtM9lmilsv/u4Mjb1RGW3hz3XqN3xwt4f23HU0dERmYcTp+iDEqPDFD2Er6SQKHrwvUcXX8/R6bXVDeMzQLoFLr4+8G9UG3Gh+3+O+wOSayLKXqWUekoptU8p9fGA3zcqpb5Z+v09Sqkx17pcsLi4yIc+9CFuvfXWyOvCBrPx9sMMlGsoOUjRgx1pS8qEEU+1CcGWrKoZuu/r62N2drZ8z/4yUL3QPQS/C8b4BN1T1IYsLn0X9q5G7cIXN0cfFOKMSqyDaHXuUsZmOqKayXhxx/xGEbBLqDufz4dOLUQ5smFTJWFlIPz9DoscVFPRBxFwKpVicHAwdMvhOKIPqmtxcXHdPh5x2+BKFP268ruuYSLzuvKPE7kuuPzLsOuawL9RbcSF7l+plLop4t/NwIUuFSul0hQT+36u9DfeppTy/613AZNa63MpZvt/xqUuVzQ2NvKlL32JO+64I/K6MOMZFaKLUrJhc5hRG/OAHWkbQxgVfnYh7WqF7qOS16LqmZiYCCwT1d9QeyfJhawgmuirFboHd0W/urpaPrrUXw+E94NL3wW1L07R24TuGxoaQiMoUWHhKCcpamrKRdFDeN+FvQthiaOuYyKMSG0dl6gTA8OmCEZGRjhy5EhoPUFlTPtgfcJgUOKjOcGuqooemMj3MTo6WvzdyP+1aSQPUBfz+zcL/kbwKSLxuBzYZ+b8lVI3lup73Ff/J0ufvw38uVJK6bAsiSojlUqxY8cODhw4EHld2GCGcKMrGZgdHR3rykQt4wsaMMvLy4FLderr60Mz26MGjIs6jytjBqEX3uQ1M3C8ZcL6ziRtmWhKXBmvUTOD0CDM4WlubiaTyVg5SZLwsy3Rx+UqFAqFdTkgUaT92GOPWdXjVc1tbZXbasT1Q7WiIS7r26P6O2wNtIszFjYlA8X37q67gjcVlbyr559/vlWZkydPBtoT/3fgNuVoHJd8Pr9O7S8tLVUca2uQTqfp7e21mgIbGRnh4YcfXnd9VBnTPlhP9IuLi1ZTOCDLug8qPzExQTabZWZmZtN3zoubo/+R4N+/OdY9DBz2/Hyk9F3gNVrrVWAa6HGszwljY2McPHgw8ppqEn1coldUmbABE1TGlKs20YeVmZ6eDtxRr9r5DVFlolZG2ChMU86m7zKZDI2NjdYRlLCEt0KhwMrKSmh/R2Wpuyj6OKIPqscfEoXolShhZGqSBW3m6KM29IkibVeiD6rHbJsbRjy2Eau4UHfUmLBR566KvlAohEZDwuxjWLJgUDIeFIn+8OHDoVMR/jMZvO2DYKJ3UfTpdHqdQ2MQRvSTk5N0dXVtyRa5Z8R59Eqp9yil7lNK3Vft4wHHxsZqouhdl+QFDbKo/e6jBlkYWUUZtbhdysKIB4LDqHEGKoxEbIm+mqF7U86mjFIqNFzrEhaO2rQjrh+i6gmbMop6rmHPKKie1tZWmpqaQskqyDkw92TjHERt6LMRoreZKomqJ5vNRhJjtQjYxZ64OAdx28yGiY2wuf2wMTEyMsLCwkKoE9vU1LQu4gnhc/RBbXPZ+8OLMKKfnp6mo6OD7u7us4ronwe8sdKR0neB1yil6oAOYF3va62/rLW+TGt9mXmxq4WdO3cyPj4eur8ybK6iD6rHkMhWKvo4hQnhiVGbpehd+huCDbULaYct8ZGEhf0EHFWPi8Nj5tvDNgGyVfRh9URtbBRWBqLHEYS/qzZz9BBO9HH9bds2lyhcHAGHbbITViasv80ukzbjKOrgmDiiD2rb4uIijY2N66aeRkaKZ6wFzdNH1dPa2kpLS4tY0adSqVCiz+VyoWF7oDwd4n/35ufnaW1t3ZK98LeS6O8F9iildimlGoC3Ajf5rrkJuLb0+ReBH2zW/LzB2NgYAIcOhW9sUO05erDzpiGatKtN9JOTk+t2KYtL4IPqqXOXKEDYMzJGLawfgvbohvCs6ah+CFMvcaH7lZUV5ufnxWXC+i5qzjhKxVRT0UN4uDaqTJRq9p9hYBAWUq926D6bzTI/P79u3XWcowh249zsd19N5yBMOIQt8w1zKMwBOrZEH7WRTVAZV6IPqyuojDllMWqZc5SiT6fTgbvrzc3Nkclktl/oXin1ZqXUb3h+vkcp9Vzp3y9upOLSnPsHgX8BngC+pbV+TCn1KaXUm0qX/SXQo5TaB/wmsG4JXq1hiD4qfB9H9EtL68+edgm1RdXjquiD1uXGEb3Wel3oLK4M1F7RR+0hHlYmSmFKnCQbpR23O1cUAfsVgIuiN8v4XPq7Ws4BuDmlYVNGUeHaqNB9mHPgQvRhfRfnHEAwAQcliHnL2fRdJpOJzG9wiaAElTEH6AQtfYt6F8zyVr+TFKS0IZroo+qB4PEXVk/UypU4RQ/B79H8/DyZTGZbhu4/SqXKbgReBrwWeP9GK9daf0drvbe0Mc/1pe9+T2t9U+nzktb6l7TW52qtL9+KXfkkRB+nRCDYCASVyWQyNDc3WxtCV6LP5/PrSDvKQIWRdrVDya2trTQ0NFgZm6iEt7h+CFPnUWWWl5fXLS0LWxkBa0uQ/M5BXOge1hO9i6KPKhOmyPL5PKurq4FlorY3dnlXXXNdwuqJIvrGxvWntkHRQM/Pz6/bWCWq78Kc82qH7k05mzJx6rxaDkV7ezstLS2BRB/3LsB6hyfKoVBK1VTRQ/xxylGKHtYTfaFQYHFxcXsqeqBBa+3NjL9La31Ka30IyNSwXdsGg4OD1NfXb0jRQ7ARiPKmbebowT10D8GDDKLVuY1RC0vUWV1dJZ/PR4YPbYx7VMJbVN8NDAyEKu2oCAqsN9RRxNPf38/KykqoYxUWugc7x8o4PGHPKCzaAOuPNI3bHCSKROLe1aBoSNSYmJycXLdyI6qesATDqHchLJHK9F2QkgsLj0uiAC4Ovcs4D5rGicuJsKlHKcXg4GDgvvoSog/ayCZIadfX19PT02M9RQBbq+hNRDeTydDe3k4ulwvcsrxWiCP6igXMWusPen6sbtbbNoVZSx+1xK7aRB/mTcYNmPn5+XVzudUmepcyTU3F86D9g0xCImHzzFFk6icrlzLmnsLKhClgiVELKgPRERSbsHCYkxSXPxDUtrhnFOYkxYVrFxcXA/MOotS51nodAUeV6e7uJpfLBdZjS/TLy8FHUYNb6L6+vp7u7u51fRf3rrpOe/jLrKysoLUO7QfbuXOAoaGhdYreOPNRYw/sxpFL20y5kydPVuQXheUcuOwu6YWf6M07aIgeYHZ2NvJvVBNxRH+PUurd/i+VUu8FflKbJm0/jI2NsX///tDfuxC9yxxmnKIHeQgsqkyUgTIEF6b8bAZnlHMARePu7zdz4I4N8YQd0uNvW5DyiyN6fz/EGSgIJ1ObbOa4/g6a045yKBobG+nq6gq8n6h6ooyuy7vq4jBHKXoIjoaE3U8U0bvcD4T3XZACNssmXfJqbISD5LlOT0+Xr5PUMzQ0tO5+ot45sFf0poztlIcpVygUKvoiLB8i6pRFF0XvJXqzuVTQCpdaIY7oPwK8Uyl1h1Lqj0v/fgi8A/hwrRu3XRC1aY7WmlwuV1UD5TKnZjvXBW4Gqq+vD6VUVQjBRdHH1RN0/rZElS4tLa3zsKOeUVioW1LGVtGn02mrMhDcdy7qPK5MWDQkTtGDbE2zgUtkLIzoXRV9VJlUKmXd30FEH/d+h+13b5vAF+coGkfW5hkF7UMvuR/bejai6KFy/EUp+qhTFqWK3jgK21rRa63HtdY/Dfx34EDp36e01q/QWgefYHAGYmxsjGPHjgUeWxjngZs1mbYEbJt4FDVnXE0lUl9fT29vb1WIPq6MK9GPj4+vC8/FtQ3s1Hk2myWVSgU6Fa6KPug5pVKpwGV5EkVvE7qHYCdJ0t8TExPlceAtZ/veuUbGwspEJTK6zNGH9UEqlQqMPtWC6IP6TjLfPjMzUzEnXIsxMTQ0xPz8fAWBxdUTdpZ9GAGbtlWL6KMUPQQnEEsVvfeo2m2t6JVSTUqpDwP/ieKe9l/QWv9gU1q2jRC1lj5uMKdSqXWZslGZzBB+vrzEeNoMmMbGRtra2qxC9xBNCDZzfhJFPzExYUXaAwMD5PP5ChUnmVYAu3nCdDpNNpu1MoRhh3hsZNrDJRpio84lih7sFJlL9Clsj4TtoOhN+1xC98eOHasID0uJ3tvfce9PkAiIexdcclCCltjF3Y9pX1DoPup+5ubmxEuWDfzjXGvtRPRSRQ9r71GQot82RA/8NXAZ8AjFU+Y+W/MWbUNELbGLM4Sw3oBKCA7sDGGY8YwaMBAc1otaIgZFI2CrRILOg5Yoen8ClosScTVqcetywxyesHqMc2BL2q5Okj9LfSOhe5cohQ1ZxZWJSkq0naPfLKKXKPpcLlcRcZCGur11xZUZGhoCqBizkncOKp9rXKJgUD1x7w8EbyQlyXUJci7j7LC33MrKCoVCIfDAnahVEVJFD8FEPzw8zHvf+16Gh/1Hu9QOcUR/odb6/9Raf4niznSv3oQ2bTtslOj9BtQlPGfqCqvHrL+3UVamLhuHAtwVPVTeU1zfBRGCRNFDMNG7hCnjDIeNgQor4zIPLgnd+50kCWnPzs5WKKWNKL+od7WlpcUqGc+cGGgzRx+2NDFqHIUdVRtH9EHTbRKih2ACtrENUqIPUtpRCW9Q+Vzj3p+oelwUfVTo3t82U1dUPR0dHTQ0NJTLhR2cA7VV9MPDw3zxi1/kkksuifwb1UQc0ZflV2knu7MSUWvpXRR91AsGblnJYTu81ZLog0KOLobDhkSkRG9joHp6ekilUtaGI0zF2RL90lL4qVveMkH9HadmvYbKhbSloXubXAUI3vglrr/D5sGjSLu1tdWK6CF4VzPXcQTRoXsIJvqwcWQIyMb5dSH6pqYmOjs7rRxmF8cFgs+yrwXRK6Uqxp9xaKMU/Ubm6GEtP8RL9FuBOKK/WCk1o5SaVUrNAi/x/Lx5EwxbjHQ6HXouvY2iN4baEL1NOLRQKJDL5UJffljvGcetYTV12STwQXFALy8vMz09Xf4uznCEZbxGlXFR51FlokLqYQlvccbdRmFCsHqJ2qkNiveUy+Uq+ls6/eNtnwtpS6MhNooegjd+kYTHbfs7TGlH1RN0vrxU0XvzSWqh6M1+90GKPko4pNPpCqKPs0Gw3imNa1vQ7nhSRX/ixImKJYOSaUpboofKe4oSXG1tbaE7c25U0W8F4rLu01rrdq11W+lfnefn9s1q5HZA2Fp6yRyUWb5lki/iBmZQUoukHr9Kkgwy44RIB5kpA3YGKorobUg7rh9aW1vJZDJWZGXaZxu6D0qadAn3S6IAYNd3QUS/kWhI2D21tLTQ1tYWOJcb13e2ij5sJUGcQ2HryLqUyWazaK0rHIRaEL2pyyZ0n06nGRgYsCZg2ylHpdS6/J04JxuK/b26ulomRfP+xIkGv6iJSnD2lpUo+qidOTc6R78VEGXdK6X+vHTme3Bs8SzAzp07OXz48LrvpSQCa4QVF7pvbW2lra3N2gD4VZJ0MPuz1KVEHzQdUU2i7+zspKGhwZq0/TkEEifJZb49KGFHMke/sLBQsUe+NInIhoCD2lYLRW/KecuYXdfiok82S8TMPdlk3UP4GvI44glyxuKIHoLnzsNIobW1ldbWVuv+dnHo/bvWuTxXF+cgztaZMrD2fseN16am9TttSsY4VD7buLa5bEVuYI6q9RJ9Op2OdRBqBZus+zcCf1zzFm1T7NixgxdeeCFwvTDEv/zAuhes2gPTKBEzRWDTNj8x2paJ89yDzoOWKoSNEo9EVQQlGEbNE0LwYSYu6jzOcIQ5SfX19evO6zZwyYnIZrMopazKmPbZTMmY9nnf1bgtWSFc0dtOlbgmWboQfVNT8Ml63rpsSdvFoQ+zJ3Hvt01ECNb3nYTobYVQUD2Stply4+PjFAqFSEUPa2cl+CFR9Ol0mo6Ojgqiz2Qyke9CLWGbdf+qTWjTtsTo6Chaa55//vmK72uh6MGd6JeXl9dNEbiQdhwpBpWRGDXbwelC9GFlJMbdEI8kFBim6OPUIqwnbZv3B+KdA7OlrU1/mwNDXJykIOMep0qXl9dO/5M8197eXqamptYt0YwjYP8BOhLHamFhoWKPfEm+BthFd2C9IyLpb7+iN/0dVcZvTyTPyOxjYZZouhC9IVMJ0ZtyUlvnSvRmmiDODnd3d6+LIBUKBVZWVmIVvSnvJ/qtQpJ1L8SOHTuA9ZvmuCh6iTft3zVLUo9/zm8jRB9VprOzk8bGxnXts5kf87bPRmm7EI+kv/v7+yucJKNkbRW9lLT9G55E3U/QNriS8KHt/g3g3ne2zph/ExdJ28xKAqOyJMmmfX19rKysrEtkrHbUJYjo4+ox7QsixjCVacp4E/8MYUWVGRoa4tSpU+VnI50igLX+lr4Lp06dKjtjkrb5+1uq6IOcnagy/rpcFL25L0kI3rt6Y7sTvcm6nzmbs+5hjej98/SSAdPd3U06nV6n6CWhNpswvH8ZjSvRx4Wsg0LqcRvzwHqilyYyuij6U6dOladZJKrC3w9SVQprxl26ygHsSCRoo504JWvuyV+PUip0GZ9pn9eBkxrdycnJcn/bkIjpO6mihzXHSuIchBGwS9QlblrBX4+Lopf2d6FQKKtNiXNgRICN2HB5RgMDA2ity2Uk99PV1UV9ff2GQvcuRC9V9P5oEES/cwanDdF7su7bz/as+9HRUSBc0Uc9+FQqJV7WYTA4OMjS0lJZidgQvY2iN3PnNooeggm4Vor+xIkTVuFD/4EcNvOENoawq6sLpVTZqEl3AfPWY9onMVCSwzi8CHLGmpubI6dXzFkB3jLpdJr6+vrIMrDW39I5em8ZSd+FEb1N5CCfz5PP5612UIP4/m5oaKCjo8NqGsfU5V1a5pK8Jinjf+8k4X6/82IzTemtRykVWY9/fbu0Hu9OmxLH3Nu+8fFxkaJfXV2t2LvfOLO2in5ubm77En2CNTQ3N5PNZp1C91AZ3pTO0YOdOncpA+GEYFNGQjz+86BNQlk6nY6sx1YhuCb3gF3CZDqdrtjEReK4BJ1D7kL00jK2zzVIYUpVkk00xE/Akr7zE710Phs2RlZxy70MgpLkJIrer87jHCt/f7vOgzc0NIQmc8L6qSmXvltYWIjN3THlXBwXG2fe3764Mv6pIjhDFX2CSuzYscOZ6L1hVOkcPdip87a2NjKZTJnopV6uSxg+aL2sxNnxngctjRxApVFraGiIdQ6gkrTr6uoiQ9b+eiTPCCqXb0nfBVcytSX6gYEB5ubmykllkjLZbJa5ubnyu2ND9DaKzL+9sU3o3pCijUPhf0aSkLW5n1wuh9Y69rkGrW+XvAtQSViSqIu3fS7z4JK2VUvRR7XLW84/9mxyXaREb6ZRJXP0QVsouyh6rTXz8/O0trbGlqkVEqK3wEaIPkjR10Kde7NrbZwQP2lL1MupU6fKIXWJc+APH7oQvavCjCvjT3iTOkneJV/Stbyu6ty/u6I0TOm9J8lzhUrjLn1GNo6sWQttQ/RGYdkYd79DIXmujY2NdHZ2Wt2Pqcs2Gc9PWAsLC7HE6BJBCSL6uPvxR1Ak4X6XsWfK2Sbjgd30BVQe+2yIPqzfqqHozVG1iaI/jTA6OhqajCdNjDJHI6ZSqcjwnH93vFoSfZDClBgorXXZ25UqeqhUcS6KXmoIbQjOHCe8EeMuMYSmfbZE39fXx9LSUsVyNImiBzei9yvMKLgQj6nLS3AQrUobGxsr5sElSraxsZH29nYrRW/uycY5gGBFH/cuBM2dx7Wtvb2dxsbGivB4XBTAv8mMZIzX19dXbLdr+iGKsMzOlP62xcHkhhQKBSfHRUr0sLbSIS56EnT6oa2ih6KjMDc3lyj60wU7duxgZmaGqamp8ndmMEvmoFZWVsrrN+MGptkdbzOI3rskRrKnPgTPsdoqTJsyNgohyKhJwofeKQwbRW8MoSGrOM89aK2xrdKuVWTDheibm5sr+tvFwZQaapcy3nXnNklbtvdjiN4k1rmE7iWOrFn1YuMcwPp7imsbBL/fNtNMNm0z69ttkjldiN60L27cmdD9RhQ9wNTUVJKMdzrhnHPOAeDZZ58tfycJz0GlMpUOssHBQat5K6hclmdD9FAM0UkVTxDR287lSvqupaWF9vZ2K0UP60nbxRCCjEROnTpVsdNW3IDu6+tjenq6XIfEEQkKQdsqehuHwqYecCNGW0UPwREUmyQ5m/fb9l3o6+sjn8+XhYBknJs5Y5f+th0T/mckqce7O97CwgL19fWRkUh/PTZz9FC0j5Ln2tbWRlNTk9VKD3/74toWNEdviN5G0Z86dYrFxcWzT9ErpbqVUrcppZ4p/d8Vct13lVJTSql/3uw2BmHPnj0APP300+XvpKTtNbrSwewlKxuiX1paYmpqysrgettmU8ZroOLK+M+DloQ2obIfpKFA/+EVtSKrbDZLoVBgcnJSTFbGqJkd26Q5EWBHwMY58Do8cW3bCNHbJjKeLoreJnQPVCy3jCvjnzKycWQ3ougl4xUqHSubceTiZEPRBknGnn9Jnouin5+fj7y+vr6etra2QKKX9J0h+iNHjgCcfUQPfBy4XWu9B7i99HMQ/gfw9k1rVQzOOecclFIbInrjsdaS6KGYrW+r4/mzLAAAGpZJREFU6L2DrBah+6D1stK+syErcAsfmnpMHgXE94M3M9mW6F362yZ0X19fT29vr5XRzWQytLS0WEVqYD3xgMxZNKFuyXy7KePiHLjM0U9NTZHL5ayiO2CXyGjatxWK3iV0bxtNs5mjB9myN4ONEP3y8jKHDx+ms7Mz8lr/7ngbIfqzMXT/ZooH5lD6/xeCLtJa3w7MBv1uK9DU1MSOHTt45plnyt9JB4w3NOVCcMbYxIWMvNn6kmVl3raNj4+LjXRXVxd1dXXWhmOjRG9jOFxUhTn33UbRQ3HawyxjsyF6G1UKdlMl4Kb8XInHJXRv1pBL539dnAPvfvcuESvbd8FL9JKIlX8KQ0raZk8Km2dkdjCUjj0Tutdai9s2Ojpafqa2it7YR5AltXrHuMTWeet66qmnRETvP9lT0jZYI3qTwH02Kvp+rbVZz3UM6N/IHysdoXufUuq+oGMFq4m9e/c6KXrvkas2CnNmZoaFhYVyPXFJf16ily7pcCGeVCrF4OBg2VuVEk81FL20nqmpKZaXl52MTS0VfdBUiSThrbW1tXzimzT06hJG9RO9tJ7JyUmWl5dZWlpCKRXrlHrJ1MbhKRQKTExMWDkHq6urFdNZ1dxYxds2cz8gf78HBwfLh2XZ2AazJ4WNc2DaJ32uvb295HI5ZmdnxdE073bh0jJmG1yTJNfY2Bi5mQ9UroKS9hus2ciJiYlYou/u7nZW9Oao2jOa6JVS31dKPRrw783e63RxYbAO+TMiaK2/rLW+TGt9mRlstcKePXt45plnKvaglzx0b6bs7OwsbW1tsWW84SwbowFFopcu6Whraysv15GqF4CxsTH2799vTTwuRG8cHlejZhs+dFFxLqF7m5CjUaZmdUQtFb3LtAdUkkicU+oleslGSN4yJ06ccCJgmzl6cH8XTO6F5P3etWsXR44cIZfLWb/fNsLBf6CLRAT4328boj906JC4bUqp8nsntY+jo6PljHYbot+9e3f5cy0VvTmqdjuE7uPjHI7QWr8+7HdKqeNKqUGt9QtKqUFgPOza7Ya9e/cyNTXFyZMnyWaz4sEMa8p0ZmamPOjiroe1wSypJ5PJ0N7ebkX0Zu7cRllB0UDdfvvtLC0tUSgURHWZegqFQk0TGTdqCBcXF0Wq1FuPUSBxxrClpYWurq6y4pGUgTWlbTsf6c07kJQZGhriJz/5CWCfTGUzNeVX9NI+8JYBu/wGl5wIEw6Ouyfvmn2zB7ukH3bv3o3WmoMHDzo5pbbOgQ2ZeqemXIheOtUGa/axp6eH9vb4o1TM+SNmHEnrGR0dpa6ujtXV1bLqDkMY0UttvhnncIYq+hjcBFxb+nwt8E9b1A5rmMx7M08vnYeDSqKXvMguCXywtsTOZpMGo7Rtlqns2rWLo0ePlgeCpC4TRjXrZW2iFMeOHbNKCAJ350A6VdLQ0EBPTw8vvPCCePkRFPtu//791orelugHBgZYXFxkenpatD8CFN+f8fHx8q5eLlnTtkQvJQQ/0cedlQCVit5FnduMCRN1sSEEozCfe+45q8x2sF/FA8VEXalt8E9NScbe8PAwSikOHjxotfWrsUE2ih7WiF5KvnV1dWV1PTIyEnmtOVPenM9hs44eikRvppPPRqL/NPAGpdQzwOtLP6OUukwp9RVzkVLqTuDvgCuUUkeUUlduSWs92Lt3L7C2xM6G6I26khK9l+BsSNuF6L27RYHMQO3atQutNY899hgge5G9BkraPheHx8UQerfBtTEcg4ODZaKXGEIoTnscOHBAPM8Ma4reds0wwIEDB8RlhoeHgeL0z/LyslPWtKTvuru7SaVSVtMr/jC8jXNgE+5va2ujoaHByjkw7fMSvcQ2GKJ/9tlnWVpasg7dS52DkZERUqkUzz33nHhdt0vovr6+nqGhIR5//HEKhUJseNxgo0QvFUJA2YE3e6OEIZvNorUuz9O7KHqDsy7rXmt9Smt9hdZ6j9b69VrridL392mtf91z3au01lmtdbPWekRr/S9b0V4vxsbGqKurKxO9jcdqjlydmpoSEX02myWVSpU9cOmL4qroXUL3AI888ghgT/TSZEFDIs8//zy5XK5mhtDsg23rWLkQ/a5du6yJ3jwjk91vQ8CG6KWKDIoK06ZtUOxv6ZhIp9P09vaWFb2kbT09PeWjgaXhfqNKDWlLpmSUUmXStt1e1dY5GBwcpLGxsewwS+ppa2ujubnZahzV19czMjJSrscmdG9D9FAM3xu7EBceNzDb4E5NTYnaZiIHLkT/hS98gRe/+MVcfvnlkdcFbfIFdore4GxU9Kct6urq2L17d5nobQjBZMoCIqJPp9Nks1kr4wlFon/hhReYmZmxJvq4gx688BO9TYLhgQMHyOfzYlWRSqXYv38/IDOETU1NdHZ2cuDAAQqFgthJGh0d5dChQ2JVAe5Ev7S0ZKW0h4aGyOfz5Tk/GwK26TtD9Pv27ROX8W47bBtJsonU1NXV0dPTY6XoGxoaynu2SxMFTdtsw/B+50BSJpVKMTY2xgMPPADEJ4jBWl7N4cOHWVhYEKvmsbExK8e8tbWV1tZWjh49ak30xkZKif6cc85hdXWVhx9+WDT2GhoaGBgY4NChQ9aHxrz1rW/lkUceKUd7whC0bXd9fX3sigADL9FL7UktkBC9A84999zyNrg2Rs07HyRJxoO1eX3b0H0ul2Pfvn3lbRzjYObOzT75UuKpr6+3MhymD5588klAFs4yDo9RmFJjMzw8zOOPPw7Ijc3Y2BgHDx4UT6/A2lbFc3NzVkQP8MQTTwCy/jZTOaYfbBIZbR0KWHtGUgNlMvxtnV/JdqReGNVsk+hl8htskme9pC1do23WnZvDh6T9sHv37jLRe8khCgMDA2UytSF68/7Y2K3nn3/eqr9NQh7Ix94FF1wAQD6fjyVgA7PEbmZmRlyPDYIUvVTNw9qzNBtRbRUSonfA7t27ee655ygUClZK2zsfZFRTHLxEbxO6NzBhyzgYEjGGQ2Lc0+k0O3fu5OGHHwZkhqO9vZ329vYyidgQglGY0gFj5glBbgh37tzJoUOHmJmZsVL0KysrHD58WPyMxsbGgLVoiKScn+glRre3t5dUKlV2TKXh8cbGRmsnyeSgzM3NWTsHLqRtE671krZtGRvnoK+vj5WVlfK6eOn7sHv37vLJaFKi7+/v56mnngLsHFkDqW0YGRmxWhMPlUQvvR9D9FBpw6JgiH56elrsmNvA5SAuL8y9b6Wah4TonXDOOecwMzPDkSNH0Fpbee0G0hfZnBVvG7o3kA5m43g88cQTpNNpK2VqMlKldY2Ojlopeij2gykjNRzDw8PlA0ZsDOHy8jLPPPOMFdFDMZnKJhkP4N///d8B2T35nTHpPHg2my0TgjQs7HWSpAbUm0xl48DZrKaAymWGUtL2zp3bKvr5+Xlx28wzMqtyXGyDjaI3UwRSR9ZEkkAeVRwZGWH//v3k83knovd+joL3vk0/xsFL9LVQ9GajM1dFb+yqeU5bhYToHWAGpVGyUrJqbm4uJ7eYZXpxGBkZ4ejRo0xMTIiJxzuwzJnKcfASfXt7u2gOEyoNlI1CMGRlQ/Srq6uAHdEb2Ch6KO6aZRO6B5ienhYbwpaWFvr7+5mZmaG+vt4qdG8cHpskJxMNkZYZHh4u5wLY1OMSul9aWuLYsWNWpG1LwNKjSf31zM3Ncfz4cat+A6zf73PPPbf8WTrdZrLOwS50byANjw8PD5d3+5Pez0UXXVT+LHUoAC655BIAXvrSl4qu37FjBwsLC8zNzdWE6L0b+YC9or/wwguBrc24hxpumHMmw5DbQw89BNg9xAcffJDl5WXRWmsoeuCFQoFCoWBFpAZmOWAcTBRgfn5eXA9UGiipp+s1UFJHxMw1gxvRu4Q2bZSVbRlT1/Hjx+nq6hI5Vk1NTXR1dZXVok1I3UBKCN6okI2iNxEUm9A9FI/ylLatr6+PiYkJTpw4UaFQozA8PMyJEyc4ceKEuN+MU/7ss8+K+8D0m03UBeDFL35x+bNxNuPgvfe49eAGXnvgYk+k43VsbIwLL7yQvXv3ikUDwN///d/zb//2bxWOQhS8tqQWoXuo3M3TVtFffPHFvOtd7+I3f/M3a9I2KRJF7wAzwO6//35A7oFD0RBIjZO3LpAPMqUUr371qwHEA6axsbE88G08Y2lkwguv4ZAaGy+ZSvvbG9mQGkKvkZWGD73X2ThJ5tlKCc5fl9SweftOWpdLNMTrUEjfVW8Z6XP1riSQOlaGgJ966ilxv1WD6G1zNvr7+0VJf1BJ2tL3e2hoiLGxMV73uteJxYYL0SulePTRR/mHf/gH0fUGu3fv5pprrhFf7yV673teTbhs221QX1/PV77ylbKy3yokit4BmUyG/v7+8jahNsbdFl6it6nn9ttv59ixY1Yv5fDwMCdPnrQi+le96lVApSKJg4ui904RSMt4B5eUELwKTEr0ra2t1NfXs7Ky4kT00vsxbXr88cdpaWkRG2ovmUoJy0v00vMjvIZWWsbbxzZq0cA2QjE+Pi5+v01oe2FhQRyhaG5upru7u7x6RarozcZBZp22BBdffHH5c9y+AF48+eST4uVh4OaYA1ZK3hVeWyLNBbBFX19fOXq7vLxsZVO3CxJF74g9e/aUM2trSfTeQSadU4PiemOpl29gBop0RQAUVdhtt93G9773PXEZ7+CUGl2vepHOse7cuZO9e/dy9dVXi9sGa8bZ61zEwZCuDWmbv29jEA1h2ThjXmKM2y7WwDslIyUFbz1SovdGUKSK3ts2W0UP8r5zmb6AtfHT2NhotYlLNpu1GrP19fXceeedHDx4UFzGtEvqJII70W8GvI6idMrDFmaPEXNQkU3ofrsgUfSOuPTSS7nrrruA2r783gFpElVqhfPPP5+bb75ZvCLA4PWvDz2/KBBepS0lkb1793LhhRdy2WWXietJpVLlxDUbfOMb3+A73/kOr3jFK8RlTFbteeedJy5z9dVX09DQwAc+8AFxGUOmNk6fWbZkkz/wspe9DKgk1Th4HSNp+7yKV5q05VVu0rHnSvRKKbTWVg7c0NAQjzzyCL29vTVXta985Str+veh0nmtFZm6QinFZz7zGcbHxysERDXR39/PyspK+RjmrV4q54KE6B3hJRybOVYX3HnnnTz22GM133DhDW94A5///OfL8/u1wvDwMO985zvFmbVQJO1HHnnE2nC6GNqrr77aOgrwta99jU984hO8/OUvF5fp7+8vb8kqxfnnnw/I9xKAImlfddVVvOlNbxKXGRoa4rvf/a6VY+Wdj7aZyjG49NJLRdd5nV9psqmXrKTRBrMaYmFhwUppG0W/3dSvK5RS3HjjjczNzVmF/DcLH/3oR2v6971HXieK/iyDMejnn39+zV/+V77ylZviub/hDW9gbm5uU+bWvvrVr1qX2Y5GxuCaa66xSiIysO3rK6+8kte85jW8973vFZdpbW3l1ltvtW0aV15pf4bUrbfeytNPP20Vsr7//vu54447rIjxiiuu4PbbbxcnOXnfHZspmba2Nmeir8Vyr63CW97ylq1uwpbB5WTG7YaE6B2xZ88ebrnlFut58O2OzSD5BO7o6enhhz/84VY3IxRXXXUVV111lVWZSy+9VKzmDW699VbGx8etVry88Y1v5Dvf+Y7V9Mpv//Zv87GPfYyf+ZmfEZcxf9+ca5Hg9Ib3eN/TVdFvX4l0GuCNb3wjL3nJS7a6GQkSnHWor6+3ShoF+Na3vsW//uu/Wk0rfOQjH2F5edlq/vfqq6/mNa95DZ/73Oes2pdge8LkhBw8eNBqM6jthETRJ0iQ4KxAJpPhp3/6p63KuEwXtbe3b+uoSwI7tLW10d3dzYEDB6xOtdxOSBR9ggQJEiRIEIGdO3fy9NNPs7q6WrMd+GqJhOgTJEiQIEGCCOzcuZNHH30U2PqT6FyQEH2CBAkSJEgQgbGxsfLBPgnRJ0iQIEGCBGcYvBsFJUSfIEGCBAkSnGHwEv3puBFSQvQJEiRIkCBBBLybLNXq8JxaIiH6BAkSJEiQIALeHRht92/YDkjW0SdIkCBBggQRqK+v5zOf+QxNTU1WJ/9tF2wJ0SuluoFvAmPAAeCXtdaTvmsuAb4AtAN54Hqt9Tc3t6UJEiRIkCBB7Q/PqSW2KnT/ceB2rfUe4PbSz34sAL+qtX4RcBXwP5VStT0mLkGCBAkSJDjDsFVE/2bgr0uf/xr4Bf8FWuuntdbPlD4fBcYB2fmSCRIkSJAgQQJg64i+X2v9QunzMaA/6mKl1OVAA/BsyO/fo5S6Tyl134kTJ6rb0gQJEiRIkOA0Rs3m6JVS3wcGAn51nfcHrbVWSumIvzMIfA24VmsdeO6j1vrLwJcBLrvsstC/lSBBggQJEpxtUFpvPi8qpZ4CXqu1fqFE5D/UWq87JFop1Q78EPgDrfW3hX/7BHCwmu0FeoGTVf6bW4XkXrYnknvZvjiT7ie5l+2JatzLTq114PT2Vi2vuwm4Fvh06f9/8l+glGoA/gH4GynJA4Td6EaglLpPa31Ztf/uViC5l+2J5F62L86k+0nuZXui1veyVXP0nwbeoJR6Bnh96WeUUpcppb5SuuaXgVcD71BKPVj6d8nWNDdBggQJEiQ4PbElil5rfQq4IuD7+4BfL33+OvD1TW5aggQJEiRIcEYh2QJXhi9vdQOqiORetieSe9m+OJPuJ7mX7Yma3suWJOMlSJAgQYIECTYHiaJPkCBBggQJzmAkRJ8gQYIECRKcwUiIvgSl1FVKqaeUUvuUUuv23ldKNSqlvln6/T1KqbHNb6UMSqlRpdQdSqnHlVKPKaU+FHDNa5VS054VDb+3FW39/9u721CrqjyO498fGgxUmFbQI9MoEfRApWIZNcQ02GRhFDY4DPRgEFK96EVEEIhM9KJHBmUeYGbEYSZmnOmJiswci3EItFLUa1hpZqSY1gSazFBW/16sdWt73Puc48PdZ5/j7wOHs8/e69z7X3fttdbd++yz/92QtFXSUI7zrZLtkjQ/t816SRN7EWcnks4p/L3XStoj6Z6WMo1tF0kLJe2StKGwbpykZZI25eexFe+9JZfZJOmW+qIuV1GXRyW9k/ehZ6tya3TaH3uhoj7zJG0v7EvTK97bduyrW0VdFhfqsVXS2or3Nqptqsbi2vtNRBz1D2AU6fa640m32l0HnNtS5k7g93l5FrC413G3qc+pwMS8fDzwXkl9rgRe7HWsXdZnK3BSm+3TgSWAgEuBVb2OuYs6jSLd/vmH/dIupK+7TgQ2FNY9Atyfl+8HHi553zhgS34em5fHNrAu04DRefnhsrrkbW33xwbVZx5wb4f3dRz7mlCXlu2PA3P7oW2qxuK6+42P6JMpwOaI2BIRXwJ/JyXeKSom4nkKuEqSaoyxaxGxIyLW5OXPgY3A6b2NakRdT7qxUkTESuCEfMfFJrsKeD8ijvRdHEdMRKwAPmtZ3TFBFXA1sCwiPouUjnoZKSNlz5TVJSJeiYiv8suVwBm1B3aIKtqmG92MfbVqV5c85v4c+FutQR2iNmNxrf3GE31yOvBR4fU2DpwYvyuTB4PdwIm1RHcY8kcMFwOrSjZPlbRO0hJJ59Ua2MEJ4BVJqyXdUbK9m/ZrmllUD1b90i7QXYKqfmyf2aSzRGU67Y9Ncnf+KGJhxenhfmubK4CdkTOblmhs27SMxbX2G0/0A0zSccDTwD0Rsadl8xrSaeMLgQXAc3XHdxAuj4iJwDXAXZJ+3OuADofS7Z1nAP8s2dxP7bKfSOcb+/77upIeAL4Cnqwo0i/74++ACcBFwA7SKe9+9wvaH803sm3ajcV19BtP9Ml24MzC6zPyutIykkYDY4D/1hLdIZB0DGnHejIinmndHhF7ImJvXn4JOEbSSTWH2ZWI2J6fd5HyH0xpKdJN+zXJNcCaiNjZuqGf2iXbOfwxSX7eVVKmb9pH0q3AdcAv8wB8gC72x0aIiJ0R8XWkrJ9/oDzOfmqb0cCNwOKqMk1sm4qxuNZ+44k+eRM4W9KP8tHWLFLinaLhRDwAM4FXqwaCXsufY/0J2BgRT1SUOWX4GgNJU0j7QuP+cZF0rKTjh5dJF0xtaCn2PHCzkkuB3YXTYk1UeVTSL+1SUOwXpQmqgKXANElj8+njaXldo0j6GXAfMCMi/ldRppv9sRFarlO5gfI4uxn7muKnwDsRsa1sYxPbps1YXG+/6fVViU15kK7cfo90BeoDed2vSJ0e4AekU62bgTeA8b2OuU1dLiedCloPrM2P6cAcYE4uczfwNukq25XAZb2Ou6Iu43OM63K8w21TrIuA3+S2GwIm9zruNvU5ljRxjyms64t2If1zsgPYR/q88HbSdSrLgU3Av4Bxuexk4I+F987OfWczcFtD67KZ9JnocJ8Z/pbNacBL7fbHXj8q6vOX3B/WkyaWU1vrk18fMPY1rS55/aLhflIo2+i2aTMW19pvfAtcMzOzAeZT92ZmZgPME72ZmdkA80RvZmY2wDzRm5mZDTBP9GZmZgPME72ZmdkA80RvdpSSdGIh9efHhZSmeyX9dgR+3yJJH0ia06bMFTmlZyNvQmPWj/w9ejND0jxgb0Q8NoK/YxEpBe9THcqdlcudP1KxmB1NfERvZvuRdKWkF/PyPEl/lvQfSR9KulHSI5KGJL2c7+ONpEmS/p2zhi3tJk2wpJskbciZ+laMdL3Mjlae6M2skwnAT0gZ9/4KvBYRFwD/B67Nk/0CYGZETAIWAg918XPnAldHytQ3Y0QiNzNG9zoAM2u8JRGxT9IQMAp4Oa8fAs4CzgHOB5blfDyjSPcq7+R1YJGkfwAHZFg0syPDE72ZdfIFQER8I2lffH9hzzekMUTA2xEx9WB+aETMkXQJcC2wWtKkiGhypj6zvuRT92Z2uN4FTpY0FVL+bUnndXqTpAkRsSoi5gKfsH/ubTM7QnxEb2aHJSK+lDQTmC9pDGlc+TUpVWg7j0o6m3RGYDkpvaiZHWH+ep2Z1cJfrzPrDZ+6N7O67AYe7HTDHOAF4NPaojIbcD6iNzMzG2A+ojczMxtgnujNzMwGmCd6MzOzAeaJ3szMbIB9CyYGk4gCZv2xAAAAAElFTkSuQmCC\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "from matplotlib import pyplot as plt\n",
        "\n",
        "fig, (ax1,ax2,ax3) = plt.subplots(3, 1,\n",
        "                                  sharex = False,\n",
        "                                  sharey = False,\n",
        "                                  figsize = (8,8))\n",
        "fig.suptitle('IBIs detection') \n",
        "\n",
        "t = np.arange(0, len(ppg_filt)/fs,1.0/fs)\n",
        "\n",
        "ax1.plot(t, ppg_filt, color = 'black')\n",
        "ax1.scatter(t[0] + ppg_ibis_d2max/fs,\n",
        "            ppg_filt[ppg_ibis_d2max],\n",
        "            color = 'orange',\n",
        "            marker = 'o')\n",
        "ax1.set_ylabel('PPG [V]')\n",
        "ax1.set_title('D2Max')\n",
        "\n",
        "ax2.plot(t, ppg_filt, color = 'black')\n",
        "ax2.scatter(t[0] + ppg_ibis_upslopes/fs,\n",
        "            ppg_filt[ppg_ibis_upslopes],\n",
        "            color = 'orange',\n",
        "            marker = 'o')\n",
        "ax2.set_ylabel('PPG [V]')\n",
        "ax2.set_title('Upslopes')\n",
        "\n",
        "ax3.plot(t, ppg_filt, color = 'black')\n",
        "ax3.scatter(t[0] + ppg_ibis_delineator/fs,\n",
        "            ppg_filt[ppg_ibis_delineator],\n",
        "            color = 'orange',\n",
        "            marker = 'o')\n",
        "ax3.set_xlabel('Time [s]')\n",
        "ax3.set_ylabel('PPG [V]')\n",
        "ax3.set_title('Delineator')"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "a53801ed",
      "metadata": {
        "id": "a53801ed"
      },
      "source": [
        "We'll use the 'D2max' algorithm in the rest of this tutorial"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "d30cafa3",
      "metadata": {
        "id": "d30cafa3"
      },
      "source": [
        "<div class=\"alert alert-block alert-info\"><p><b>Task:</b> Try repeating this for 'rel_segment_no = 3' How do the beat detectors perform on this patient's data?</p></div>"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "500e67f2",
      "metadata": {
        "id": "500e67f2"
      },
      "source": [
        "### Detect beats in the BP signal"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "36a19da3",
      "metadata": {
        "id": "36a19da3",
        "outputId": "36cb9aef-26a2-4b38-e474-ad47e628e54c",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Detected 30 beats in the BP signal using the D2max algorithm\n"
          ]
        }
      ],
      "source": [
        "temp_fs = 125\n",
        "abp_ibis_d2max = pulse_detect(abp_filt,temp_fs,5,'d2max')\n",
        "print(\"Detected {} beats in the BP signal using the {} algorithm\".format(len(abp_ibis_d2max), \"D2max\"))"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "65a2f117",
      "metadata": {
        "id": "65a2f117"
      },
      "source": [
        "### Plot the results"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "956b1637",
      "metadata": {
        "id": "956b1637",
        "outputId": "fe99e538-eedc-4197-97e1-404853cbde5e",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 572
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0, 0.5, 'ABP [au]')"
            ]
          },
          "metadata": {},
          "execution_count": 15
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 576x576 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "from matplotlib import pyplot as plt\n",
        "\n",
        "fig, (ax1,ax2) = plt.subplots(2, 1,\n",
        "                              sharex = False,\n",
        "                              sharey = False,\n",
        "                              figsize = (8,8))\n",
        "fig.suptitle('IBIs detection') \n",
        "\n",
        "t = np.arange(0,len(ppg_filt)/fs,1.0/fs)\n",
        "\n",
        "ax1.plot(t, ppg_filt, color = 'black')\n",
        "ax1.scatter(t[0] + ppg_ibis_d2max/fs,\n",
        "            ppg_filt[ppg_ibis_d2max],\n",
        "            color = 'orange',\n",
        "            marker = 'o')\n",
        "ax1.set_ylabel('PPG [au]')\n",
        "\n",
        "ax2.plot(t, abp_filt, color = 'black')\n",
        "ax2.scatter(t[0] + abp_ibis_d2max/fs,\n",
        "            abp_filt[abp_ibis_d2max],\n",
        "            color = 'orange',\n",
        "            marker = 'o')\n",
        "ax2.set_xlabel('Time [s]')\n",
        "ax2.set_ylabel('ABP [au]')"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "6de63716",
      "metadata": {
        "id": "6de63716"
      },
      "source": [
        "<div class=\"alert alert-block alert-warning\"> <b>Note:</b> In this case, beats are accurately detected in both BP and PPG signals.</div>"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "41e8edf5",
      "metadata": {
        "id": "41e8edf5"
      },
      "source": [
        "---\n",
        "## Functions"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "1ecd26af",
      "metadata": {
        "id": "1ecd26af"
      },
      "source": [
        "The following functions are required for this tutorial. Run the cell below and then return to the top of the page."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "36fb7dce",
      "metadata": {
        "tags": [
          "hide-input"
        ],
        "id": "36fb7dce"
      },
      "outputs": [],
      "source": [
        "import scipy.signal as sp\n",
        "import numpy as np\n",
        "\n",
        "def pulse_detect(x,fs,w,alg):\n",
        "    \"\"\"\n",
        "    Description: Pulse detection and correction from pulsatile signals\n",
        "    Inputs:  x, array with pulsatile signal [user defined units]\n",
        "             fs, sampling rate of signal [Hz]\n",
        "             w, window length for analysis [s]\n",
        "             alg, string with the name of the algorithm to apply ['heartpy','d2max','upslopes','delineator']\n",
        "    Outputs: ibis, location of cardiac cycles as detected by the selected algorithm [number of samples]\n",
        "\n",
        "    Algorithms:       1: HeartPy (van Gent et al, 2019, DOI: 10.1016/j.trf.2019.09.015)\n",
        "                      2: 2nd derivative maxima (Elgendi et al, 2013, DOI: 10.1371/journal.pone.0076585)\n",
        "                      3: Systolic upslopes (Arguello Prada and Serna Maldonado, 2018,\n",
        "                         DOI: 10.1080/03091902.2019.1572237)\n",
        "                      4: Delineator (Li et al, 2010, DOI: 10.1109/TBME.2005.855725)\n",
        "    Fiducial points:  1: Systolic peak (pks)\n",
        "                      2: Onset, as the minimum before the systolic peak (ons)\n",
        "                      3: Onset, using the tangent intersection method (ti)\n",
        "                      4: Diastolic peak (dpk)\n",
        "                      5: Maximum slope (m1d)\n",
        "                      6: a point from second derivative PPG (a2d)\n",
        "                      7: b point from second derivative PPG (b2d)\n",
        "                      8: c point from second derivative PPG (c2d)\n",
        "                      9: d point from second derivative PPG (d2d)\n",
        "                      10: e point from second derivative PPG (e2d)\n",
        "                      11: p1 from the third derivative PPG (p1)\n",
        "                      12: p2 from the third derivative PPG (p2)\n",
        "\n",
        "    Libraries: NumPy (as np), SciPy (Signal, as sp), Matplotlib (PyPlot, as plt)\n",
        "\n",
        "    Version: 1.0 - June 2022\n",
        "\n",
        "    Developed by: Elisa Mejía-Mejía\n",
        "                   City, University of London\n",
        "\n",
        "    \"\"\"\n",
        "\n",
        "    # Check selected algorithm\n",
        "    pos_alg = ['heartpy','d2max','upslopes','delineator']\n",
        "    if not(alg in pos_alg):\n",
        "        print('Unknown algorithm determined. Using D2max as default')\n",
        "        alg = 'd2max'\n",
        "\n",
        "    # Pre-processing of signal\n",
        "    x_d = sp.detrend(x)\n",
        "    sos = sp.butter(10, [0.5, 10], btype = 'bp', analog = False, output = 'sos', fs = fs)\n",
        "    x_f = sp.sosfiltfilt(sos, x_d)\n",
        "\n",
        "    # Peak detection in windows of length w\n",
        "    n_int = np.floor(len(x_f)/(w*fs))\n",
        "    for i in range(int(n_int)):\n",
        "        start = i*fs*w\n",
        "        stop = (i + 1)*fs*w - 1\n",
        "        # print('Start: ' + str(start) + ', stop: ' + str(stop) + ', fs: ' + str(fs))\n",
        "        aux = x_f[range(start,stop)]\n",
        "        if alg == 'heartpy':\n",
        "            locs = heartpy(aux,fs,40,180,5)\n",
        "        elif alg == 'd2max':\n",
        "            locs = d2max(aux,fs)\n",
        "        elif alg == 'upslopes':\n",
        "            locs = upslopes(aux)\n",
        "        elif alg == 'delineator':\n",
        "            locs = delineator(aux,fs)\n",
        "        locs = locs + start\n",
        "        if i == 0:\n",
        "            ibis = locs\n",
        "        else:\n",
        "            ibis = np.append(ibis,locs)\n",
        "    if n_int*fs*w != len(x_f):\n",
        "        start = stop + 1\n",
        "        stop = len(x_f)\n",
        "        aux = x_f[range(start,stop)]\n",
        "        if len(aux) > 20:\n",
        "            if alg == 'heartpy':\n",
        "                locs = heartpy(aux,fs,40,180,5)\n",
        "            elif alg == 'd2max':\n",
        "                locs = d2max(aux,fs)\n",
        "            elif alg == 'upslopes':\n",
        "                locs = upslopes(aux)\n",
        "            elif alg == 'delineator':\n",
        "                locs = delineator(aux,fs)\n",
        "            locs = locs + start\n",
        "            ibis = np.append(ibis,locs)\n",
        "    ind, = np.where(ibis <= len(x_f))\n",
        "    ibis = ibis[ind]\n",
        "\n",
        "    ibis = peak_correction(x,ibis,fs,20,5,[0.5, 1.5])\n",
        "\n",
        "    #fig = plt.figure()\n",
        "    #plt.plot(x)\n",
        "    #plt.plot(x_d)\n",
        "    #plt.plot(x_f)\n",
        "    #plt.scatter(ibis,x_f[ibis],marker = 'o',color = 'red')\n",
        "    #plt.scatter(ibis,x[ibis],marker = 'o',color = 'red')\n",
        "\n",
        "    return ibis\n",
        "\n",
        "def peak_correction(x,locs,fs,t,stride,th_len):\n",
        "    \"\"\"\n",
        "    Correction of peaks detected from pulsatile signals\n",
        "\n",
        "    Inputs:   x, pulsatile signal [user defined units]\n",
        "              locs, location of the detected interbeat intervals [number of samples]\n",
        "              fs, sampling rate [Hz]\n",
        "              t, duration of intervals for the correction [s]\n",
        "              stride, stride between consecutive intervals for the correction [s]\n",
        "              th_len, array with the percentage of lower and higher thresholds for comparing the duration of IBIs\n",
        "              [proportions]\n",
        "    Outputs:  ibis, array with the corrected points related to the start of the inter-beat intervals [number of samples]\n",
        "\n",
        "    Developed by:  Elisa Mejía Mejía\n",
        "                   City, University of London\n",
        "    Version:       1.0 -   June, 2022\n",
        "\n",
        "    \"\"\"\n",
        "\n",
        "    #fig = plt.figure()\n",
        "    #plt.plot(x)\n",
        "    #plt.scatter(locs,x[locs],marker = 'o',color = 'red', label = 'Original')\n",
        "    #plt.title('Peak correction')\n",
        "\n",
        "    # Correction of long and short IBIs\n",
        "    len_window = np.round(t*fs)\n",
        "    #print('Window length: ' + str(len_window))\n",
        "    first_i = 0\n",
        "    second_i = len_window - 1\n",
        "    while second_i < len(x):\n",
        "        ind1, = np.where(locs >= first_i)\n",
        "        ind2, = np.where(locs <= second_i)\n",
        "        ind = np.intersect1d(ind1, ind2)\n",
        "\n",
        "        win = locs[ind]\n",
        "        dif = np.diff(win)\n",
        "        #print('Indices: ' + str(ind) + ', locs: ' + str(locs[ind]) + ', dif: ' + str(dif))\n",
        "\n",
        "        th_dif = np.zeros(2)\n",
        "        th_dif[0] = th_len[0]*np.median(dif)\n",
        "        th_dif[1] = th_len[1]*np.median(dif)\n",
        "\n",
        "        th_amp = np.zeros(2)\n",
        "        th_amp[0] = 0.75*np.median(x[win])\n",
        "        th_amp[1] = 1.25*np.median(x[win])\n",
        "        #print('Length thresholds: ' + str(th_dif) + ', amplitude thresholds: ' + str(th_amp))\n",
        "\n",
        "        j = 0\n",
        "        while j < len(dif):\n",
        "            if dif[j] <= th_dif[0]:\n",
        "                if j == 0:\n",
        "                    opt = np.append(win[j], win[j + 1])\n",
        "                else:\n",
        "                    opt = np.append(win[j], win[j + 1]) - win[j - 1]\n",
        "                print('Optional: ' + str(opt))\n",
        "                dif_abs = np.abs(opt - np.median(dif))\n",
        "                min_val = np.min(dif_abs)\n",
        "                ind_min, = np.where(dif_abs == min_val)\n",
        "                print('Minimum: ' + str(min_val) + ', index: ' + str(ind_min))\n",
        "                if ind_min == 0:\n",
        "                    print('Original window: ' + str(win), end = '')\n",
        "                    win = np.delete(win, win[j + 1])\n",
        "                    print(', modified window: ' + str(win))\n",
        "                else:\n",
        "                    print('Original window: ' + str(win), end = '')\n",
        "                    win = np.delete(win, win[j])\n",
        "                    print(', modified window: ' + str(win))\n",
        "                dif = np.diff(win)\n",
        "            elif dif[j] >= th_dif[1]:\n",
        "                aux_x = x[win[j]:win[j + 1]]\n",
        "                locs_pks, _ = sp.find_peaks(aux_x)\n",
        "                #fig = plt.figure()\n",
        "                #plt.plot(aux_x)\n",
        "                #plt.scatter(locs_pks,aux_x[locs_pks],marker = 'o',color = 'red')\n",
        "\n",
        "                locs_pks = locs_pks + win[j]\n",
        "                ind1, = np.where(x[locs_pks] >= th_amp[0])\n",
        "                ind2, = np.where(x[locs_pks] <= th_amp[1])\n",
        "                ind = np.intersect1d(ind1, ind2)\n",
        "                locs_pks = locs_pks[ind]\n",
        "                #print('Locations: ' + str(locs_pks))\n",
        "\n",
        "                if len(locs_pks) != 0:\n",
        "                    opt = locs_pks - win[j]\n",
        "\n",
        "                    dif_abs = np.abs(opt - np.median(dif))\n",
        "                    min_val = np.min(dif_abs)\n",
        "                    ind_min, = np.where(dif_abs == min_val)\n",
        "\n",
        "                    win = np.append(win, locs_pks[ind_min])\n",
        "                    win = np.sort(win)\n",
        "                    dif = np.diff(win)\n",
        "                    j = j + 1\n",
        "                else:\n",
        "                    opt = np.round(win[j] + np.median(dif))\n",
        "                    if opt < win[j + 1]:\n",
        "                        win = np.append(win, locs_pks[ind_min])\n",
        "                        win = np.sort(win)\n",
        "                        dif = np.diff(win)\n",
        "                        j = j + 1\n",
        "                    else:\n",
        "                        j = j + 1\n",
        "            else:\n",
        "                j = j + 1\n",
        "\n",
        "        locs = np.append(win, locs)\n",
        "        locs = np.sort(locs)\n",
        "\n",
        "        first_i = first_i + stride*fs - 1\n",
        "        second_i = second_i + stride*fs - 1\n",
        "\n",
        "    dif = np.diff(locs)\n",
        "    dif = np.append(0, dif)\n",
        "    ind, = np.where(dif != 0)\n",
        "    locs = locs[ind]\n",
        "\n",
        "    #plt.scatter(locs,x[locs],marker = 'o',color = 'green', label = 'After length correction')\n",
        "\n",
        "    # Correction of points that are not peaks\n",
        "    i = 0\n",
        "    pre_loc = 0\n",
        "    while i < len(locs):\n",
        "        if locs[i] == 0:\n",
        "            locs = np.delete(locs, locs[i])\n",
        "        elif locs[i] == len(x):\n",
        "            locs = np.delete(locs, locs[i])\n",
        "        else:\n",
        "            #print('Previous: ' + str(x[locs[i] - 1]) + ', actual: ' + str(x[locs[i]]) + ', next: ' + str(x[locs[i] + 1]))\n",
        "            cond = (x[locs[i]] >= x[locs[i] - 1]) and (x[locs[i]] >= x[locs[i] + 1])\n",
        "            #print('Condition: ' + str(cond))\n",
        "            if cond:\n",
        "                i = i + 1\n",
        "            else:\n",
        "                if locs[i] == pre_loc:\n",
        "                    i = i + 1\n",
        "                else:\n",
        "                    if i == 0:\n",
        "                        aux = x[0:locs[i + 1] - 1]\n",
        "                        aux_loc = locs[i] - 1\n",
        "                        aux_start = 0\n",
        "                    elif i == len(locs) - 1:\n",
        "                        aux = x[locs[i - 1]:len(x) - 1]\n",
        "                        aux_loc = locs[i] - locs[i - 1]\n",
        "                        aux_start = locs[i - 1]\n",
        "                    else:\n",
        "                        aux = x[locs[i - 1]:locs[i + 1]]\n",
        "                        aux_loc = locs[i] - locs[i - 1]\n",
        "                        aux_start = locs[i - 1]\n",
        "                    #print('i ' + str(i) + ' out of ' + str(len(locs)) + ', aux length: ' + str(len(aux)) +\n",
        "                    #      ', location: ' + str(aux_loc))\n",
        "                    #print('Locs i - 1: ' + str(locs[i - 1]) + ', locs i: ' + str(locs[i]) + ', locs i + 1: ' + str(locs[i + 1]))\n",
        "\n",
        "                    pre = find_closest_peak(aux, aux_loc, 'backward')\n",
        "                    pos = find_closest_peak(aux, aux_loc, 'forward')\n",
        "                    #print('Previous: ' + str(pre) + ', next: ' + str(pos) + ', actual: ' + str(aux_loc))\n",
        "\n",
        "                    ibi_pre = np.append(pre - 1, len(aux) - pre)\n",
        "                    ibi_pos = np.append(pos - 1, len(aux) - pos)\n",
        "                    ibi_act = np.append(aux_loc - 1, len(aux) - aux_loc)\n",
        "                    #print('Previous IBIs: ' + str(ibi_pre) + ', next IBIs: ' + str(ibi_pos) +\n",
        "                    #      ', actual IBIs: ' + str(ibi_act))\n",
        "\n",
        "                    dif_pre = np.abs(ibi_pre - np.mean(np.diff(locs)))\n",
        "                    dif_pos = np.abs(ibi_pos - np.mean(np.diff(locs)))\n",
        "                    dif_act = np.abs(ibi_act - np.mean(np.diff(locs)))\n",
        "                    #print('Previous DIF: ' + str(dif_pre) + ', next DIF: ' + str(dif_pos) +\n",
        "                    #      ', actual DIF: ' + str(dif_act))\n",
        "\n",
        "                    avgs = [np.mean(dif_pre), np.mean(dif_pos), np.mean(dif_act)]\n",
        "                    min_avg = np.min(avgs)\n",
        "                    ind, = np.where(min_avg == avgs)\n",
        "                    #print('Averages: ' + str(avgs) + ', min index: ' + str(ind))\n",
        "                    if len(ind) != 0:\n",
        "                        ind = ind[0]\n",
        "\n",
        "                    if ind == 0:\n",
        "                        locs[i] = pre + aux_start - 1\n",
        "                    elif ind == 1:\n",
        "                        locs[i] = pos + aux_start - 1\n",
        "                    elif ind == 2:\n",
        "                        locs[i] = aux_loc + aux_start - 1\n",
        "                    i = i + 1\n",
        "\n",
        "    #plt.scatter(locs,x[locs],marker = 'o',color = 'yellow', label = 'After not-peak correction')\n",
        "\n",
        "    # Correction of peaks according to amplitude\n",
        "    len_window = np.round(t*fs)\n",
        "    #print('Window length: ' + str(len_window))\n",
        "    keep = np.empty(0)\n",
        "    first_i = 0\n",
        "    second_i = len_window - 1\n",
        "    while second_i < len(x):\n",
        "        ind1, = np.where(locs >= first_i)\n",
        "        ind2, = np.where(locs <= second_i)\n",
        "        ind = np.intersect1d(ind1, ind2)\n",
        "        win = locs[ind]\n",
        "        if np.median(x[win]) > 0:\n",
        "            th_amp_low = 0.5*np.median(x[win])\n",
        "            th_amp_high = 3*np.median(x[win])\n",
        "        else:\n",
        "            th_amp_low = -3*np.median(x[win])\n",
        "            th_amp_high = 1.5*np.median(x[win])\n",
        "        ind1, = np.where(x[win] >= th_amp_low)\n",
        "        ind2, = np.where(x[win] <= th_amp_high)\n",
        "        aux_keep = np.intersect1d(ind1,ind2)\n",
        "        keep = np.append(keep, aux_keep)\n",
        "\n",
        "        first_i = second_i + 1\n",
        "        second_i = second_i + stride*fs - 1\n",
        "\n",
        "    if len(keep) != 0:\n",
        "        keep = np.unique(keep)\n",
        "        locs = locs[keep.astype(int)]\n",
        "\n",
        "    #plt.scatter(locs,x[locs],marker = 'o',color = 'purple', label = 'After amplitude correction')\n",
        "    #plt.legend()\n",
        "\n",
        "    return locs\n",
        "\n",
        "def find_closest_peak(x, loc, dir_search):\n",
        "    \"\"\"\n",
        "    Finds the closest peak to the initial location in x\n",
        "\n",
        "    Inputs:   x, signal of interest [user defined units]\n",
        "              loc, initial location [number of samples]\n",
        "              dir_search, direction of search ['backward','forward']\n",
        "    Outputs:  pos, location of the first peak detected in specified direction [number of samples]\n",
        "\n",
        "    Developed by:  Elisa Mejía Mejía\n",
        "                   City, University of London\n",
        "    Version:       1.0 -   June, 2022\n",
        "\n",
        "    \"\"\"\n",
        "\n",
        "    pos = -1\n",
        "    if dir_search == 'backward':\n",
        "        i = loc - 2\n",
        "        while i > 0:\n",
        "            if (x[i] > x[i - 1]) and (x[i] > x[i + 1]):\n",
        "                pos = i\n",
        "                i = 0\n",
        "            else:\n",
        "                i = i - 1\n",
        "        if pos == -1:\n",
        "            pos = loc\n",
        "    elif dir_search == 'forward':\n",
        "        i = loc + 1\n",
        "        while i < len(x) - 1:\n",
        "            if (x[i] > x[i - 1]) and (x[i] > x[i + 1]):\n",
        "                pos = i\n",
        "                i = len(x)\n",
        "            else:\n",
        "                i = i + 1\n",
        "        if pos == -1:\n",
        "            pos = loc\n",
        "\n",
        "    return pos\n",
        "\n",
        "def seek_local(x, start, end):\n",
        "    val_min = x[start]\n",
        "    val_max = x[start]\n",
        "\n",
        "    ind_min = start\n",
        "    ind_max = start\n",
        "\n",
        "    for j in range(start, end):\n",
        "        if x[j] > val_max:\n",
        "            val_max = x[j]\n",
        "            ind_max = j\n",
        "        elif x[j] < val_min:\n",
        "            val_min = x[j]\n",
        "            ind_min = j\n",
        "\n",
        "    return val_min, ind_min, val_max, ind_max\n",
        "\n",
        "def heartpy(x, fs, min_ihr, max_ihr, w):\n",
        "    \"\"\"\n",
        "    Detects inter-beat intervals using HeartPy\n",
        "    Citation: van Gent P, Farah H, van Nes N, van Arem B (2019) Heartpy: A novel heart rate algorithm\n",
        "              for the analysis of noisy signals. Transp Res Part F, vol. 66, pp. 368-378. DOI: 10.1016/j.trf.2019.09.015\n",
        "\n",
        "    Inputs:   x, pulsatile signal [user defined units]\n",
        "              fs, sampling rate [Hz]\n",
        "              min_ihr, minimum value of instantaneous heart rate to be accepted [bpm]\n",
        "              max_ihr, maximum value of instantaneous heart rate to be accepted [bpm]\n",
        "              w, length of segments for correction of peaks [s]\n",
        "    Outputs:  ibis, position of the starting points of inter-beat intervals [number of samples]\n",
        "\n",
        "    Developed by:  Elisa Mejía Mejía\n",
        "                   City, University of London\n",
        "    Version:       1.0 -   June, 2022\n",
        "\n",
        "    \"\"\"\n",
        "\n",
        "    # Identification of peaks\n",
        "    is_roi = 0\n",
        "    n_rois = 0\n",
        "    pos_pks = np.empty(0).astype(int)\n",
        "    locs = np.empty(0).astype(int)\n",
        "\n",
        "    len_ma = int(np.round(0.75*fs))\n",
        "    #print(len_ma)\n",
        "    sig = np.append(x[0]*np.ones(len_ma), x)\n",
        "    sig = np.append(sig, x[-1]*np.ones(len_ma))\n",
        "\n",
        "    i = len_ma\n",
        "    while i < len(sig) - len_ma:\n",
        "        ma = np.mean(sig[i - len_ma:i + len_ma - 1])\n",
        "        #print(len(sig[i - len_ma:i + len_ma - 1]),ma)\n",
        "\n",
        "        # If it is the beginning of a new ROI:\n",
        "        if is_roi == 0 and sig[i] >= ma:\n",
        "            is_roi = 1\n",
        "            n_rois = n_rois + 1\n",
        "            #print('New ROI ---' + str(n_rois) + ' @ ' + str(i))\n",
        "            # If it is a peak:\n",
        "            if sig[i] >= sig[i - 1] and sig[i] >= sig[i + 1]:\n",
        "                pos_pks = np.append(pos_pks, int(i))\n",
        "                #print('Possible peaks: ' + str(pos_pks))\n",
        "\n",
        "        # If it is part of a ROI which is not over:\n",
        "        elif is_roi == 1 and sig[i] > ma:\n",
        "            #print('Actual ROI ---' + str(n_rois) + ' @ ' + str(i))\n",
        "            # If it is a peak:\n",
        "            if sig[i] >= sig[i - 1] and sig[i] >= sig[i + 1]:\n",
        "                pos_pks = np.append(pos_pks, int(i))\n",
        "                #print('Possible peaks: ' + str(pos_pks))\n",
        "\n",
        "        # If the ROI is over or the end of the signal has been reached:\n",
        "        elif is_roi == 1 and (sig[i] < ma or i == (len(sig) - len_ma)):\n",
        "            #print('End of ROI ---' + str(n_rois) + ' @ ' + str(i) + '. Pos pks: ' + str(pos_pks))\n",
        "            is_roi = 0 # Lowers flag\n",
        "\n",
        "            # If it is the end of the first ROI:\n",
        "            if n_rois == 1:\n",
        "                # If at least one peak has been found:\n",
        "                if len(pos_pks) != 0:\n",
        "                    # Determines the location of the maximum peak:\n",
        "                    max_pk = np.max(sig[pos_pks])\n",
        "                    ind, = np.where(max_pk == np.max(sig[pos_pks]))\n",
        "                    #print('First ROI: (1) Max Peak: ' + str(max_pk) + ', amplitudes: ' + str(sig[pos_pks]) +\n",
        "                    #      ', index: ' + str(int(ind)), ', pk_ind: ' + str(pos_pks[ind]))\n",
        "                    # The maximum peak is added to the list:\n",
        "                    locs = np.append(locs, pos_pks[ind])\n",
        "                    #print('Locations: ' + str(locs))\n",
        "                # If no peak was found:\n",
        "                else:\n",
        "                    # Counter for ROIs is reset to previous value:\n",
        "                    n_rois = n_rois - 1\n",
        "\n",
        "            # If it is the end of the second ROI:\n",
        "            elif n_rois == 2:\n",
        "                # If at least one peak has been found:\n",
        "                if len(pos_pks) != 0:\n",
        "                    # Measures instantantaneous HR of found peaks with respect to the previous peak:\n",
        "                    ihr = 60/((pos_pks - locs[-1])/fs)\n",
        "                    good_ihr, = np.where(ihr <= max_ihr and ihr >= min_ihr)\n",
        "                    #print('Second ROI IHR check: (1) IHR: ' + str(ihr) + ', valid peaks: ' + str(good_ihr) +\n",
        "                    #      ', pos_pks before: ' + str(pos_pks) + ', pos_pks after: ' + str(pos_pks[good_ihr]))\n",
        "                    pos_pks = pos_pks[good_ihr].astype(int)\n",
        "\n",
        "                    # If at least one peak is between HR limits:\n",
        "                    if len(pos_pks) != 0:\n",
        "                        # Determines the location of the maximum peak:\n",
        "                        max_pk = np.max(sig[pos_pks])\n",
        "                        ind, = np.where(max_pk == np.max(sig[pos_pks]))\n",
        "                        #print('Second ROI: (1) Max Peak: ' + str(max_pk) + ', amplitudes: ' + str(sig[pos_pks]) +\n",
        "                        #  ', index: ' + str(int(ind)), ', pk_ind: ' + str(pos_pks[ind]))\n",
        "                        # The maximum peak is added to the list:\n",
        "                        locs = np.append(locs, pos_pks[ind])\n",
        "                        #print('Locations: ' + str(locs))\n",
        "                # If no peak was found:\n",
        "                else:\n",
        "                    # Counter for ROIs is reset to previous value:\n",
        "                    n_rois = n_rois - 1\n",
        "\n",
        "            # If it is the end of the any further ROI:\n",
        "            else:\n",
        "                # If at least one peak has been found:\n",
        "                if len(pos_pks) != 0:\n",
        "                    # Measures instantantaneous HR of found peaks with respect to the previous peak:\n",
        "                    ihr = 60/((pos_pks - locs[-1])/fs)\n",
        "                    good_ihr, = np.where(ihr <= max_ihr and ihr >= min_ihr)\n",
        "                    #print('Third ROI IHR check: (1) IHR: ' + str(ihr) + ', valid peaks: ' + str(good_ihr) +\n",
        "                    #      ', pos_pks before: ' + str(pos_pks) + ', pos_pks after: ' + str(pos_pks[good_ihr]))\n",
        "                    pos_pks = pos_pks[good_ihr].astype(int)\n",
        "\n",
        "                    # If at least one peak is between HR limits:\n",
        "                    if len(pos_pks) != 0:\n",
        "                        # Calculates SDNN with the possible peaks on the ROI:\n",
        "                        sdnn = np.zeros(len(pos_pks))\n",
        "                        for j in range(len(pos_pks)):\n",
        "                            sdnn[j] = np.std(np.append(locs/fs, pos_pks[j]/fs))\n",
        "                        # Determines the new peak as that one with the lowest SDNN:\n",
        "                        min_pk = np.min(sdnn)\n",
        "                        ind, = np.where(min_pk == np.min(sdnn))\n",
        "                        #print('Third ROI: (1) Min SDNN Peak: ' + str(min_pk) + ', amplitudes: ' + str(sig[pos_pks]) +\n",
        "                        #  ', index: ' + str(int(ind)), ', pk_ind: ' + str(pos_pks[ind]))\n",
        "                        locs = np.append(locs, pos_pks[ind])\n",
        "                        #print('Locations: ' + str(locs))\n",
        "                # If no peak was found:\n",
        "                else:\n",
        "                    # Counter for ROIs is reset to previous value:\n",
        "                    n_rois = n_rois - 1\n",
        "\n",
        "            # Resets possible peaks for next ROI:\n",
        "            pos_pks = np.empty(0)\n",
        "\n",
        "        i = i + 1;\n",
        "\n",
        "    locs = locs - len_ma\n",
        "\n",
        "    # Correction of peaks\n",
        "    c_locs = np.empty(0)\n",
        "    n_int = np.floor(len(x)/(w*fs))\n",
        "    for i in range(int(n_int)):\n",
        "        ind1, = np.where(locs >= i*w*fs)\n",
        "        #print('Locs >= ' + str((i)*w*fs) + ': ' + str(locs[ind1]))\n",
        "        ind2, = np.where(locs < (i + 1)*w*fs)\n",
        "        #print('Locs < ' + str((i + 1)*w*fs) + ': ' + str(locs[ind2]))\n",
        "        ind = np.intersect1d(ind1, ind2)\n",
        "        #print('Larger and lower than locs: ' + str(locs[ind]))\n",
        "        int_locs = locs[ind]\n",
        "\n",
        "        if i == 0:\n",
        "            aux_ibis = np.diff(int_locs)\n",
        "        else:\n",
        "            ind, = np.where(locs >= i*w*fs)\n",
        "            last = locs[ind[0] - 1]\n",
        "            aux_ibis = np.diff(np.append(last, int_locs))\n",
        "        avg_ibis = np.mean(aux_ibis)\n",
        "        th = np.append((avg_ibis - 0.3*avg_ibis), (avg_ibis + 0.3*avg_ibis))\n",
        "        ind1, = np.where(aux_ibis > th[0])\n",
        "        #print('Ind1: ' + str(ind1))\n",
        "        ind2, = np.where(aux_ibis < th[1])\n",
        "        #print('Ind2: ' + str(ind2))\n",
        "        ind = np.intersect1d(ind1, ind2)\n",
        "        #print('Ind: ' + str(ind))\n",
        "\n",
        "        c_locs = np.append(c_locs, int_locs[ind]).astype(int)\n",
        "        print(c_locs)\n",
        "\n",
        "    #fig = plt.figure()\n",
        "    #plt.plot(x)\n",
        "    #plt.plot(sig)\n",
        "    #plt.scatter(locs,x[locs],marker = 'o',color = 'red')\n",
        "    #if len(c_locs) != 0:\n",
        "        #plt.scatter(c_locs,x[c_locs],marker = 'o',color = 'blue')\n",
        "\n",
        "    if len(c_locs) != 0:\n",
        "        ibis = c_locs\n",
        "    else:\n",
        "        ibis = locs\n",
        "\n",
        "    return ibis\n",
        "\n",
        "def d2max(x, fs):\n",
        "    \"\"\"\n",
        "    Detects inter-beat intervals using D2Max\n",
        "    Citation: Elgendi M, Norton I, Brearley M, Abbott D, Schuurmans D (2013) Systolic Peak Detection in Acceleration\n",
        "              Photoplethysmograms Measured from Emergency Responders in Tropical Conditions. PLoS ONE, vol. 8, no. 10,\n",
        "              pp. e76585. DOI: 10.1371/journal.pone.0076585\n",
        "\n",
        "    Inputs:   x, pulsatile signal [user defined units]\n",
        "              fs, sampling rate [Hz]\n",
        "    Outputs:  ibis, position of the starting points of inter-beat intervals [number of samples]\n",
        "\n",
        "    Developed by:  Elisa Mejía Mejía\n",
        "                   City, University of London\n",
        "    Version:       1.0 -   June, 2022\n",
        "\n",
        "    \"\"\"\n",
        "\n",
        "    # Bandpass filter\n",
        "    if len(x) < 4098:\n",
        "        z_fill = np.zeros(4098 - len(x) + 1)\n",
        "        x_z = np.append(x, z_fill)\n",
        "    sos = sp.butter(10, [0.5, 8], btype = 'bp', analog = False, output = 'sos', fs = fs)\n",
        "    x_f = sp.sosfiltfilt(sos, x_z)\n",
        "\n",
        "    # Signal clipping\n",
        "    ind, = np.where(x_f < 0)\n",
        "    x_c = x_f\n",
        "    x_c[ind] = 0\n",
        "\n",
        "    # Signal squaring\n",
        "    x_s = x_c**2\n",
        "\n",
        "    #plt.figure()\n",
        "    #plt.plot(x)\n",
        "    #plt.plot(x_z)\n",
        "    #plt.plot(x_f)\n",
        "    #plt.plot(x_c)\n",
        "    #plt.plot(x_s)\n",
        "\n",
        "    # Blocks of interest\n",
        "    w1 = (111e-3)*fs\n",
        "    w1 = int(2*np.floor(w1/2) + 1)\n",
        "    b = (1/w1)*np.ones(w1)\n",
        "    ma_pk = sp.filtfilt(b,1,x_s)\n",
        "\n",
        "    w2 = (667e-3)*fs\n",
        "    w2 = int(2*np.floor(w2/2) + 1)\n",
        "    b = (1/w2)*np.ones(w1)\n",
        "    ma_bpm = sp.filtfilt(b,1,x_s)\n",
        "\n",
        "    #plt.figure()\n",
        "    #plt.plot(x_s/np.max(x_s))\n",
        "    #plt.plot(ma_pk/np.max(ma_pk))\n",
        "    #plt.plot(ma_bpm/np.max(ma_bpm))\n",
        "\n",
        "    # Thresholding\n",
        "    alpha = 0.02*np.mean(ma_pk)\n",
        "    th_1 = ma_bpm + alpha\n",
        "    th_2 = w1\n",
        "    boi = (ma_pk > th_1).astype(int)\n",
        "\n",
        "    blocks_init, = np.where(np.diff(boi) > 0)\n",
        "    blocks_init = blocks_init + 1\n",
        "    blocks_end, = np.where(np.diff(boi) < 0)\n",
        "    blocks_end = blocks_end + 1\n",
        "    if blocks_init[0] > blocks_end[0]:\n",
        "        blocks_init = np.append(1, blocks_init)\n",
        "    if blocks_init[-1] > blocks_end[-1]:\n",
        "        blocks_end = np.append(blocks_end, len(x_s))\n",
        "    #print('Initial locs BOI: ' + str(blocks_init))\n",
        "    #print('Final locs BOI: ' + str(blocks_end))\n",
        "\n",
        "    #plt.figure()\n",
        "    #plt.plot(x_s[range(len(x))]/np.max(x_s))\n",
        "    #plt.plot(boi[range(len(x))])\n",
        "\n",
        "    # Search for peaks inside BOIs\n",
        "    len_blks = np.zeros(len(blocks_init))\n",
        "    ibis = np.zeros(len(blocks_init))\n",
        "    for i in range(len(blocks_init)):\n",
        "        ind, = np.where(blocks_end > blocks_init[i])\n",
        "        ind = ind[0]\n",
        "        len_blks[i] = blocks_end[ind] - blocks_init[i]\n",
        "        if len_blks[i] >= th_2:\n",
        "            aux = x[blocks_init[i]:blocks_end[ind]]\n",
        "            if len(aux) != 0:\n",
        "                max_val = np.max(aux)\n",
        "                max_ind, = np.where(max_val == aux)\n",
        "                ibis[i] = max_ind + blocks_init[i] - 1\n",
        "\n",
        "    ind, = np.where(len_blks < th_2)\n",
        "    if len(ind) != 0:\n",
        "        for i in range(len(ind)):\n",
        "            boi[blocks_init[i]:blocks_end[i]] = 0\n",
        "    ind, = np.where(ibis == 0)\n",
        "    ibis = (np.delete(ibis, ind)).astype(int)\n",
        "\n",
        "    #plt.plot(boi[range(len(x))])\n",
        "\n",
        "    #plt.figure()\n",
        "    #plt.plot(x)\n",
        "    #plt.scatter(ibis, x[ibis], marker = 'o',color = 'red')\n",
        "\n",
        "    return ibis\n",
        "\n",
        "def upslopes(x):\n",
        "    \"\"\"\n",
        "    Detects inter-beat intervals using Upslopes\n",
        "    Citation: Arguello Prada EJ, Serna Maldonado RD (2018) A novel and low-complexity peak detection algorithm for\n",
        "              heart rate estimation from low-amplitude photoplethysmographic (PPG) signals. J Med Eng Technol, vol. 42,\n",
        "              no. 8, pp. 569-577. DOI: 10.1080/03091902.2019.1572237\n",
        "\n",
        "    Inputs:   x, pulsatile signal [user defined units]\n",
        "    Outputs:  ibis, position of the starting points of inter-beat intervals [number of samples]\n",
        "\n",
        "    Developed by:  Elisa Mejía Mejía\n",
        "                   City, University of London\n",
        "    Version:       1.0 -   June, 2022\n",
        "\n",
        "    \"\"\"\n",
        "\n",
        "    # Peak detection\n",
        "    th = 6\n",
        "    pks = np.empty(0)\n",
        "    pos_pk = np.empty(0)\n",
        "    pos_pk_b = 0\n",
        "    n_pos_pk = 0\n",
        "    n_up = 0\n",
        "\n",
        "    for i in range(1, len(x)):\n",
        "        if x[i] > x[i - 1]:\n",
        "            n_up = n_up + 1\n",
        "        else:\n",
        "            if n_up > th:\n",
        "                pos_pk = np.append(pos_pk, i)\n",
        "                pos_pk_b = 1\n",
        "                n_pos_pk = n_pos_pk + 1\n",
        "                n_up_pre = n_up\n",
        "            else:\n",
        "                pos_pk = pos_pk.astype(int)\n",
        "                #print('Possible peaks: ' + str(pos_pk) + ', number of peaks: ' + str(n_pos_pk))\n",
        "                if pos_pk_b == 1:\n",
        "                    if x[i - 1] > x[pos_pk[n_pos_pk - 1]]:\n",
        "                        pos_pk[n_pos_pk - 1] = i - 1\n",
        "                    else:\n",
        "                        pks = np.append(pks, pos_pk[n_pos_pk - 1])\n",
        "                    th = 0.6*n_up_pre\n",
        "                    pos_pk_b = 0\n",
        "            n_up = 0\n",
        "    ibis = pks.astype(int)\n",
        "    #print(ibis)\n",
        "\n",
        "    #plt.figure()\n",
        "    #plt.plot(x)\n",
        "    #plt.scatter(ibis, x[ibis], marker = 'o',color = 'red')\n",
        "\n",
        "    return ibis\n",
        "\n",
        "def delineator(x, fs):\n",
        "    \"\"\"\n",
        "    Detects inter-beat intervals using Delineator\n",
        "    Citation: Li BN, Dong MC, Vai MI (2010) On an automatic delineator for arterial blood pressure waveforms. Biomed\n",
        "    Signal Process Control, vol. 5, no. 1, pp. 76-81. DOI: 10.1016/j.bspc.2009.06.002\n",
        "\n",
        "    Inputs:   x, pulsatile signal [user defined units]\n",
        "              fs, sampling rate [Hz]\n",
        "    Outputs:  ibis, position of the starting points of inter-beat intervals [number of samples]\n",
        "\n",
        "    Developed by:  Elisa Mejía Mejía\n",
        "                   City, University of London\n",
        "    Version:       1.0 -   June, 2022\n",
        "\n",
        "    \"\"\"\n",
        "\n",
        "    # Lowpass filter\n",
        "    od = 3\n",
        "    sos = sp.butter(od, 25, btype = 'low', analog = False, output = 'sos', fs = fs)\n",
        "    x_f = sp.sosfiltfilt(sos, x)\n",
        "    x_m = 1000*x_f\n",
        "\n",
        "    #plt.figure()\n",
        "    #plt.plot(x)\n",
        "    #plt.plot(x_f)\n",
        "    #plt.plot(x_m)\n",
        "\n",
        "    # Moving average\n",
        "    n = 5\n",
        "    b = (1/n)*np.ones(n)\n",
        "    x_ma = sp.filtfilt(b,1,x_m)\n",
        "\n",
        "    # Compute differentials\n",
        "    dif = np.diff(x_ma)\n",
        "    dif = 100*np.append(dif[0], dif)\n",
        "    dif_ma = sp.filtfilt(b,1,dif)\n",
        "\n",
        "    #plt.figure()\n",
        "    #plt.plot(x_ma)\n",
        "    #plt.plot(dif_ma)\n",
        "\n",
        "    # Average thresholds in original signal\n",
        "    x_len = len(x)\n",
        "    if x_len > 12*fs:\n",
        "        n = 10\n",
        "    elif x_len > 7*fs:\n",
        "        n = 5\n",
        "    elif x_len > 4*fs:\n",
        "        n = 2\n",
        "    else:\n",
        "        n = 1\n",
        "    #print(n)\n",
        "\n",
        "    max_min = np.empty(0)\n",
        "    if n > 1:\n",
        "        #plt.figure()\n",
        "        #plt.plot(x_ma)\n",
        "        n_int = np.floor(x_len/(n + 2))\n",
        "        #print('Length of intervals: ' + str(n_int))\n",
        "        for j in range(n):\n",
        "            # Searches for max and min in 1 s intervals\n",
        "            amp_min, ind_min, amp_max, ind_max = seek_local(x_ma, int(j*n_int), int(j*n_int + fs))\n",
        "            #plt.scatter(ind_min, amp_min, marker = 'o', color = 'red')\n",
        "            #plt.scatter(ind_max, amp_max, marker = 'o', color = 'green')\n",
        "            max_min = np.append(max_min, (amp_max - amp_min))\n",
        "        max_min_avg = np.mean(max_min)\n",
        "        #print('Local max and min: ' + str(max_min) + ', average amplitude: ' + str(max_min_avg))\n",
        "    else:\n",
        "        amp_min, ind_min , amp_max, ind_max = seek_local(x_ma, int(close_win), int(x_len))\n",
        "        #plt.figure()\n",
        "        #plt.plot(x_ma)\n",
        "        #plt.scatter(ind_min, amp_min, marker = 'o', color = 'red')\n",
        "        #plt.scatter(ind_max, amp_max, marker = 'o', color = 'green')\n",
        "        max_min_avg = amp_max - amp_min\n",
        "        #print('Local max and min: ' + str(max_min) + ', average amplitude: ' + str(max_min_avg))\n",
        "\n",
        "    max_min_lt = 0.4*max_min_avg\n",
        "\n",
        "    # Seek pulse beats by min-max method\n",
        "    step_win = 2*fs       # Window length to look for peaks/onsets\n",
        "    close_win = np.floor(0.1*fs)\n",
        "                          # Value of what is considered too close\n",
        "\n",
        "    pks = np.empty(0)     # Location of peaks\n",
        "    ons = np.empty(0)     # Location of onsets\n",
        "    dic = np.empty(0)     # Location of dicrotic notches\n",
        "\n",
        "    pk_index = -1          # Number of peaks found\n",
        "    on_index = -1          # Number of onsets found\n",
        "    dn_index = -1          # Number of dicrotic notches found\n",
        "\n",
        "    i = int(close_win)    # Initializes counter\n",
        "    while i < x_len:      # Iterates through the signal\n",
        "        #print('i: ' + str(i))\n",
        "        amp_min = x_ma[i] # Gets the initial value for the minimum amplitude\n",
        "        amp_max = x_ma[i] # Gets the initial value for the maximum amplitude\n",
        "\n",
        "        ind = i           # Initializes the temporal location of the index\n",
        "        aux_pks = i       # Initializes the temporal location of the peak\n",
        "        aux_ons = i       # Initializes the temporal location of the onset\n",
        "\n",
        "        # Iterates while ind is lower than the length of the signal\n",
        "        while ind < x_len - 1:\n",
        "            #print('Ind: ' + str(ind))\n",
        "            # Verifies if no peak has been found in 2 seconds\n",
        "            if (ind - i) > step_win:\n",
        "                #print('Peak not found in 2 s')\n",
        "                ind = i   # Refreshes the temporal location of the index\n",
        "                max_min_avg = 0.6*max_min_avg  # Refreshes the threshold for the amplitude\n",
        "                # Verifies if the threshold is lower than the lower limit\n",
        "                if max_min_avg <= max_min_lt:\n",
        "                    max_min_avg = 2.5*max_min_lt # Refreshes the threshold\n",
        "                break\n",
        "\n",
        "            # Verifies if the location is a candidate peak\n",
        "            if (dif_ma[ind - 1]*dif_ma[ind + 1]) <= 0:\n",
        "                #print('There is a candidate peak')\n",
        "                # Determines initial and end points of a window to search for local peaks and onsets\n",
        "                if (ind + 5) < x_len:\n",
        "                    i_stop = ind + 5\n",
        "                else:\n",
        "                    i_stop = x_len - 1\n",
        "                if (ind - 5) >= 0:\n",
        "                    i_start = ind - 5\n",
        "                else:\n",
        "                    i_start = 0\n",
        "\n",
        "                # Checks for artifacts of saturated or signal loss\n",
        "                if (i_stop - ind) >= 5:\n",
        "                    for j in range(ind, i_stop):\n",
        "                        if dif_ma[j] != 0:\n",
        "                            break\n",
        "                    if j == i_stop:\n",
        "                        #print('Artifact')\n",
        "                        break\n",
        "\n",
        "                # Candidate onset\n",
        "                #print('Looking for candidate onsets...')\n",
        "                #plt.figure()\n",
        "                #plt.plot(x_ma)\n",
        "                if dif_ma[i_start] < 0:\n",
        "                    if dif_ma[i_stop] > 0:\n",
        "                        aux_min, ind_min, _, _ = seek_local(x_ma, int(i_start), int(i_stop))\n",
        "                        #plt.scatter(ind_min, aux_min, marker = 'o', color = 'red')\n",
        "                        if np.abs(ind_min - ind) <= 2:\n",
        "                            amp_min = aux_min\n",
        "                            aux_ons = ind_min\n",
        "                #print('Candidate onset: ' + str([ind_min, amp_min]))\n",
        "                # Candidate peak\n",
        "                #print('Looking for candidate peaks...')\n",
        "                if dif_ma[i_start] > 0:\n",
        "                    if dif_ma[i_stop] < 0:\n",
        "                        _, _, aux_max, ind_max = seek_local(x_ma, int(i_start), int(i_stop))\n",
        "                        #plt.scatter(ind_max, aux_max, marker = 'o', color = 'green')\n",
        "                        if np.abs(ind_max - ind) <= 2:\n",
        "                            amp_max = aux_max\n",
        "                            aux_pks = ind_max\n",
        "                #print('Candidate peak: ' + str([ind_max, amp_max]))\n",
        "                # Verifies if the amplitude of the pulse is larger than 0.4 times the mean value:\n",
        "                #print('Pulse amplitude: ' + str(amp_max - amp_min) + ', thresholds: ' +\n",
        "                #      str([0.4*max_min_avg, 2*max_min_avg]))\n",
        "                if (amp_max - amp_min) > 0.4*max_min_avg:\n",
        "                    #print('Expected amplitude of pulse')\n",
        "                    # Verifies if the amplitude of the pulse is lower than 2 times the mean value:\n",
        "                    if (amp_max - amp_min) < 2*max_min_avg:\n",
        "                        #print('Expected duration of pulse')\n",
        "                        if aux_pks > aux_ons:\n",
        "                            #print('Refining onsets...')\n",
        "                            # Refine onsets:\n",
        "                            aux_min = x_ma[aux_ons]\n",
        "                            temp_ons = aux_ons\n",
        "                            for j in range(aux_pks, aux_ons + 1, -1):\n",
        "                                if x_ma[j] < aux_min:\n",
        "                                    aux_min = x_ma[j]\n",
        "                                    temp_ons = j\n",
        "                            amp_min = aux_min\n",
        "                            aux_ons = temp_ons\n",
        "\n",
        "                            # If there is at least one peak found before:\n",
        "                            #print('Number of previous peaks: ' + str(pk_index + 1))\n",
        "                            if pk_index >= 0:\n",
        "                                #print('There were previous peaks')\n",
        "                                #print('Duration of ons to peak interval: ' + str(aux_ons - pks[pk_index]) +\n",
        "                                #     ', threshold: ' + str([3*close_win, step_win]))\n",
        "                                # If the duration of the pulse is too short:\n",
        "                                if (aux_ons - pks[pk_index]) < 3*close_win:\n",
        "                                    #print('Too short interbeat interval')\n",
        "                                    ind = i\n",
        "                                    max_min_avg = 2.5*max_min_lt\n",
        "                                    break\n",
        "                                # If the time difference between consecutive peaks is longer:\n",
        "                                if (aux_pks - pks[pk_index]) > step_win:\n",
        "                                    #print('Too long interbeat interval')\n",
        "                                    pk_index = pk_index - 1\n",
        "                                    on_index = on_index - 1\n",
        "                                    #if dn_index > 0:\n",
        "                                    #    dn_index = dn_index - 1\n",
        "                                # If there are still peaks, add the new peak:\n",
        "                                if pk_index >= 0:\n",
        "                                    #print('There are still previous peaks')\n",
        "                                    pk_index = pk_index + 1\n",
        "                                    on_index = on_index + 1\n",
        "                                    pks = np.append(pks, aux_pks)\n",
        "                                    ons = np.append(ons, aux_ons)\n",
        "                                    #print('Peaks: ' + str(pks))\n",
        "                                    #print('Onsets: ' + str(ons))\n",
        "\n",
        "                                    tf = ons[pk_index] - ons[pk_index - 1]\n",
        "\n",
        "                                    to = np.floor(fs/20)\n",
        "                                    tff = np.floor(0.1*tf)\n",
        "                                    if tff < to:\n",
        "                                        to = tff\n",
        "                                    to = pks[pk_index - 1] + to\n",
        "\n",
        "                                    te = np.floor(fs/20)\n",
        "                                    tff = np.floor(0.5*tf)\n",
        "                                    if tff < te:\n",
        "                                        te = tff\n",
        "                                    te = pks[pk_index - 1] + te\n",
        "\n",
        "                                    #tff = seek_dicrotic(dif_ma[to:te])\n",
        "                                    #if tff == 0:\n",
        "                                    #    tff = te - pks[pk_index - 1]\n",
        "                                    #    tff = np.floor(tff/3)\n",
        "                                    #dn_index = dn_index + 1\n",
        "                                    #dic[dn_index] = to + tff\n",
        "\n",
        "                                    ind = ind + close_win\n",
        "                                    break\n",
        "                            # If it is the first peak:\n",
        "                            if pk_index < 0:\n",
        "                                #print('There were no previous peaks')\n",
        "                                pk_index = pk_index + 1\n",
        "                                on_index = on_index + 1\n",
        "                                pks = np.append(pks, aux_pks)\n",
        "                                ons = np.append(ons, aux_ons)\n",
        "                                #print('Peaks: ' + str(pks))\n",
        "                                #print('Onsets: ' + str(ons))\n",
        "                                ind = ind + close_win\n",
        "                                break\n",
        "\n",
        "            ind = ind + 1\n",
        "        i = int(ind + 1)\n",
        "\n",
        "    if len(pks) == 0:\n",
        "        return -1\n",
        "    else:\n",
        "        x_len = len(pks)\n",
        "        temp_p = np.empty(0)\n",
        "        for i in range(x_len):\n",
        "            temp_p = np.append(temp_p, pks[i] - od)\n",
        "        ttk = temp_p[0]\n",
        "        if ttk < 0:\n",
        "            temp_p[0] = 0\n",
        "        pks = temp_p\n",
        "\n",
        "        x_len = len(ons)\n",
        "        temp_o = np.empty(0)\n",
        "        for i in range(x_len):\n",
        "            temp_o = np.append(temp_o, ons[i] - od)\n",
        "        ttk = temp_o[0]\n",
        "        if ttk < 0:\n",
        "            temp_o[0] = 0\n",
        "        ons = temp_o\n",
        "\n",
        "    pks = pks + 5\n",
        "    ibis = pks.astype(int)\n",
        "\n",
        "    return ibis\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "bded67b5",
      "metadata": {
        "id": "bded67b5"
      },
      "source": [
        "Now return to [this step](#detect-beats-in-the-PPG-signal)"
      ]
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.8.8"
    },
    "toc": {
      "base_numbering": 1,
      "nav_menu": {},
      "number_sections": true,
      "sideBar": true,
      "skip_h1_title": true,
      "title_cell": "Table of Contents",
      "title_sidebar": "Contents",
      "toc_cell": false,
      "toc_position": {},
      "toc_section_display": true,
      "toc_window_display": true
    },
    "colab": {
      "name": "beat-detection.ipynb",
      "provenance": []
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}